mirror of
https://github.com/Tautulli/Tautulli.git
synced 2025-08-14 02:26:58 -07:00
Update datutil-2.8.2
This commit is contained in:
JonnyWong16
parent
439ca8ebb8
commit
3b645cf6c3
37 changed files with 16696 additions and 2664 deletions
0
lib/dateutil/test/__init__.py
Normal file
0
lib/dateutil/test/__init__.py
Normal file
233
lib/dateutil/test/_common.py
Normal file
233
lib/dateutil/test/_common.py
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
from __future__ import unicode_literals
|
||||
import os
|
||||
import time
|
||||
import subprocess
|
||||
import warnings
|
||||
import tempfile
|
||||
import pickle
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
class PicklableMixin(object):
|
||||
def _get_nobj_bytes(self, obj, dump_kwargs, load_kwargs):
|
||||
"""
|
||||
Pickle and unpickle an object using ``pickle.dumps`` / ``pickle.loads``
|
||||
"""
|
||||
pkl = pickle.dumps(obj, **dump_kwargs)
|
||||
return pickle.loads(pkl, **load_kwargs)
|
||||
|
||||
def _get_nobj_file(self, obj, dump_kwargs, load_kwargs):
|
||||
"""
|
||||
Pickle and unpickle an object using ``pickle.dump`` / ``pickle.load`` on
|
||||
a temporary file.
|
||||
"""
|
||||
with tempfile.TemporaryFile('w+b') as pkl:
|
||||
pickle.dump(obj, pkl, **dump_kwargs)
|
||||
pkl.seek(0) # Reset the file to the beginning to read it
|
||||
nobj = pickle.load(pkl, **load_kwargs)
|
||||
|
||||
return nobj
|
||||
|
||||
def assertPicklable(self, obj, singleton=False, asfile=False,
|
||||
dump_kwargs=None, load_kwargs=None):
|
||||
"""
|
||||
Assert that an object can be pickled and unpickled. This assertion
|
||||
assumes that the desired behavior is that the unpickled object compares
|
||||
equal to the original object, but is not the same object.
|
||||
"""
|
||||
get_nobj = self._get_nobj_file if asfile else self._get_nobj_bytes
|
||||
dump_kwargs = dump_kwargs or {}
|
||||
load_kwargs = load_kwargs or {}
|
||||
|
||||
nobj = get_nobj(obj, dump_kwargs, load_kwargs)
|
||||
if not singleton:
|
||||
self.assertIsNot(obj, nobj)
|
||||
self.assertEqual(obj, nobj)
|
||||
|
||||
|
||||
class TZContextBase(object):
|
||||
"""
|
||||
Base class for a context manager which allows changing of time zones.
|
||||
|
||||
Subclasses may define a guard variable to either block or or allow time
|
||||
zone changes by redefining ``_guard_var_name`` and ``_guard_allows_change``.
|
||||
The default is that the guard variable must be affirmatively set.
|
||||
|
||||
Subclasses must define ``get_current_tz`` and ``set_current_tz``.
|
||||
"""
|
||||
_guard_var_name = "DATEUTIL_MAY_CHANGE_TZ"
|
||||
_guard_allows_change = True
|
||||
|
||||
def __init__(self, tzval):
|
||||
self.tzval = tzval
|
||||
self._old_tz = None
|
||||
|
||||
@classmethod
|
||||
def tz_change_allowed(cls):
|
||||
"""
|
||||
Class method used to query whether or not this class allows time zone
|
||||
changes.
|
||||
"""
|
||||
guard = bool(os.environ.get(cls._guard_var_name, False))
|
||||
|
||||
# _guard_allows_change gives the "default" behavior - if True, the
|
||||
# guard is overcoming a block. If false, the guard is causing a block.
|
||||
# Whether tz_change is allowed is therefore the XNOR of the two.
|
||||
return guard == cls._guard_allows_change
|
||||
|
||||
@classmethod
|
||||
def tz_change_disallowed_message(cls):
|
||||
""" Generate instructions on how to allow tz changes """
|
||||
msg = ('Changing time zone not allowed. Set {envar} to {gval} '
|
||||
'if you would like to allow this behavior')
|
||||
|
||||
return msg.format(envar=cls._guard_var_name,
|
||||
gval=cls._guard_allows_change)
|
||||
|
||||
def __enter__(self):
|
||||
if not self.tz_change_allowed():
|
||||
msg = self.tz_change_disallowed_message()
|
||||
pytest.skip(msg)
|
||||
|
||||
# If this is used outside of a test suite, we still want an error.
|
||||
raise ValueError(msg) # pragma: no cover
|
||||
|
||||
self._old_tz = self.get_current_tz()
|
||||
self.set_current_tz(self.tzval)
|
||||
|
||||
def __exit__(self, type, value, traceback):
|
||||
if self._old_tz is not None:
|
||||
self.set_current_tz(self._old_tz)
|
||||
|
||||
self._old_tz = None
|
||||
|
||||
def get_current_tz(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def set_current_tz(self):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class TZEnvContext(TZContextBase):
|
||||
"""
|
||||
Context manager that temporarily sets the `TZ` variable (for use on
|
||||
*nix-like systems). Because the effect is local to the shell anyway, this
|
||||
will apply *unless* a guard is set.
|
||||
|
||||
If you do not want the TZ environment variable set, you may set the
|
||||
``DATEUTIL_MAY_NOT_CHANGE_TZ_VAR`` variable to a truthy value.
|
||||
"""
|
||||
_guard_var_name = "DATEUTIL_MAY_NOT_CHANGE_TZ_VAR"
|
||||
_guard_allows_change = False
|
||||
|
||||
def get_current_tz(self):
|
||||
return os.environ.get('TZ', UnsetTz)
|
||||
|
||||
def set_current_tz(self, tzval):
|
||||
if tzval is UnsetTz and 'TZ' in os.environ:
|
||||
del os.environ['TZ']
|
||||
else:
|
||||
os.environ['TZ'] = tzval
|
||||
|
||||
time.tzset()
|
||||
|
||||
|
||||
class TZWinContext(TZContextBase):
|
||||
"""
|
||||
Context manager for changing local time zone on Windows.
|
||||
|
||||
Because the effect of this is system-wide and global, it may have
|
||||
unintended side effect. Set the ``DATEUTIL_MAY_CHANGE_TZ`` environment
|
||||
variable to a truthy value before using this context manager.
|
||||
"""
|
||||
def get_current_tz(self):
|
||||
p = subprocess.Popen(['tzutil', '/g'], stdout=subprocess.PIPE)
|
||||
|
||||
ctzname, err = p.communicate()
|
||||
ctzname = ctzname.decode() # Popen returns
|
||||
|
||||
if p.returncode:
|
||||
raise OSError('Failed to get current time zone: ' + err)
|
||||
|
||||
return ctzname
|
||||
|
||||
def set_current_tz(self, tzname):
|
||||
p = subprocess.Popen('tzutil /s "' + tzname + '"')
|
||||
|
||||
out, err = p.communicate()
|
||||
|
||||
if p.returncode:
|
||||
raise OSError('Failed to set current time zone: ' +
|
||||
(err or 'Unknown error.'))
|
||||
|
||||
|
||||
###
|
||||
# Utility classes
|
||||
class NotAValueClass(object):
|
||||
"""
|
||||
A class analogous to NaN that has operations defined for any type.
|
||||
"""
|
||||
def _op(self, other):
|
||||
return self # Operation with NotAValue returns NotAValue
|
||||
|
||||
def _cmp(self, other):
|
||||
return False
|
||||
|
||||
__add__ = __radd__ = _op
|
||||
__sub__ = __rsub__ = _op
|
||||
__mul__ = __rmul__ = _op
|
||||
__div__ = __rdiv__ = _op
|
||||
__truediv__ = __rtruediv__ = _op
|
||||
__floordiv__ = __rfloordiv__ = _op
|
||||
|
||||
__lt__ = __rlt__ = _op
|
||||
__gt__ = __rgt__ = _op
|
||||
__eq__ = __req__ = _op
|
||||
__le__ = __rle__ = _op
|
||||
__ge__ = __rge__ = _op
|
||||
|
||||
|
||||
NotAValue = NotAValueClass()
|
||||
|
||||
|
||||
class ComparesEqualClass(object):
|
||||
"""
|
||||
A class that is always equal to whatever you compare it to.
|
||||
"""
|
||||
|
||||
def __eq__(self, other):
|
||||
return True
|
||||
|
||||
def __ne__(self, other):
|
||||
return False
|
||||
|
||||
def __le__(self, other):
|
||||
return True
|
||||
|
||||
def __ge__(self, other):
|
||||
return True
|
||||
|
||||
def __lt__(self, other):
|
||||
return False
|
||||
|
||||
def __gt__(self, other):
|
||||
return False
|
||||
|
||||
__req__ = __eq__
|
||||
__rne__ = __ne__
|
||||
__rle__ = __le__
|
||||
__rge__ = __ge__
|
||||
__rlt__ = __lt__
|
||||
__rgt__ = __gt__
|
||||
|
||||
|
||||
ComparesEqual = ComparesEqualClass()
|
||||
|
||||
|
||||
class UnsetTzClass(object):
|
||||
""" Sentinel class for unset time zone variable """
|
||||
pass
|
||||
|
||||
|
||||
UnsetTz = UnsetTzClass()
|
||||
41
lib/dateutil/test/conftest.py
Normal file
41
lib/dateutil/test/conftest.py
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
import os
|
||||
import pytest
|
||||
|
||||
|
||||
# Configure pytest to ignore xfailing tests
|
||||
# See: https://stackoverflow.com/a/53198349/467366
|
||||
def pytest_collection_modifyitems(items):
|
||||
for item in items:
|
||||
marker_getter = getattr(item, 'get_closest_marker', None)
|
||||
|
||||
# Python 3.3 support
|
||||
if marker_getter is None:
|
||||
marker_getter = item.get_marker
|
||||
|
||||
marker = marker_getter('xfail')
|
||||
|
||||
# Need to query the args because conditional xfail tests still have
|
||||
# the xfail mark even if they are not expected to fail
|
||||
if marker and (not marker.args or marker.args[0]):
|
||||
item.add_marker(pytest.mark.no_cover)
|
||||
|
||||
|
||||
def set_tzpath():
|
||||
"""
|
||||
Sets the TZPATH variable if it's specified in an environment variable.
|
||||
"""
|
||||
tzpath = os.environ.get('DATEUTIL_TZPATH', None)
|
||||
|
||||
if tzpath is None:
|
||||
return
|
||||
|
||||
path_components = tzpath.split(':')
|
||||
|
||||
print("Setting TZPATH to {}".format(path_components))
|
||||
|
||||
from dateutil import tz
|
||||
tz.TZPATHS.clear()
|
||||
tz.TZPATHS.extend(path_components)
|
||||
|
||||
|
||||
set_tzpath()
|
||||
27
lib/dateutil/test/property/test_isoparse_prop.py
Normal file
27
lib/dateutil/test/property/test_isoparse_prop.py
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
from hypothesis import given, assume
|
||||
from hypothesis import strategies as st
|
||||
|
||||
from dateutil import tz
|
||||
from dateutil.parser import isoparse
|
||||
|
||||
import pytest
|
||||
|
||||
# Strategies
|
||||
TIME_ZONE_STRATEGY = st.sampled_from([None, tz.UTC] +
|
||||
[tz.gettz(zname) for zname in ('US/Eastern', 'US/Pacific',
|
||||
'Australia/Sydney', 'Europe/London')])
|
||||
ASCII_STRATEGY = st.characters(max_codepoint=127)
|
||||
|
||||
|
||||
@pytest.mark.isoparser
|
||||
@given(dt=st.datetimes(timezones=TIME_ZONE_STRATEGY), sep=ASCII_STRATEGY)
|
||||
def test_timespec_auto(dt, sep):
|
||||
if dt.tzinfo is not None:
|
||||
# Assume offset has no sub-second components
|
||||
assume(dt.utcoffset().total_seconds() % 60 == 0)
|
||||
|
||||
sep = str(sep) # Python 2.7 requires bytes
|
||||
dtstr = dt.isoformat(sep=sep)
|
||||
dt_rt = isoparse(dtstr)
|
||||
|
||||
assert dt_rt == dt
|
||||
22
lib/dateutil/test/property/test_parser_prop.py
Normal file
22
lib/dateutil/test/property/test_parser_prop.py
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
from hypothesis.strategies import integers
|
||||
from hypothesis import given
|
||||
|
||||
import pytest
|
||||
|
||||
from dateutil.parser import parserinfo
|
||||
|
||||
|
||||
@pytest.mark.parserinfo
|
||||
@given(integers(min_value=100, max_value=9999))
|
||||
def test_convertyear(n):
|
||||
assert n == parserinfo().convertyear(n)
|
||||
|
||||
|
||||
@pytest.mark.parserinfo
|
||||
@given(integers(min_value=-50,
|
||||
max_value=49))
|
||||
def test_convertyear_no_specified_century(n):
|
||||
p = parserinfo()
|
||||
new_year = p._year + n
|
||||
result = p.convertyear(new_year % 100, century_specified=False)
|
||||
assert result == new_year
|
||||
35
lib/dateutil/test/property/test_tz_prop.py
Normal file
35
lib/dateutil/test/property/test_tz_prop.py
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
from datetime import datetime, timedelta
|
||||
|
||||
import pytest
|
||||
import six
|
||||
from hypothesis import assume, given
|
||||
from hypothesis import strategies as st
|
||||
|
||||
from dateutil import tz as tz
|
||||
|
||||
EPOCHALYPSE = datetime.fromtimestamp(2147483647)
|
||||
NEGATIVE_EPOCHALYPSE = datetime.fromtimestamp(0) - timedelta(seconds=2147483648)
|
||||
|
||||
|
||||
@pytest.mark.gettz
|
||||
@pytest.mark.parametrize("gettz_arg", [None, ""])
|
||||
# TODO: Remove bounds when GH #590 is resolved
|
||||
@given(
|
||||
dt=st.datetimes(
|
||||
min_value=NEGATIVE_EPOCHALYPSE, max_value=EPOCHALYPSE, timezones=st.just(tz.UTC),
|
||||
)
|
||||
)
|
||||
def test_gettz_returns_local(gettz_arg, dt):
|
||||
act_tz = tz.gettz(gettz_arg)
|
||||
if isinstance(act_tz, tz.tzlocal):
|
||||
return
|
||||
|
||||
dt_act = dt.astimezone(tz.gettz(gettz_arg))
|
||||
if six.PY2:
|
||||
dt_exp = dt.astimezone(tz.tzlocal())
|
||||
else:
|
||||
dt_exp = dt.astimezone()
|
||||
|
||||
assert dt_act == dt_exp
|
||||
assert dt_act.tzname() == dt_exp.tzname()
|
||||
assert dt_act.utcoffset() == dt_exp.utcoffset()
|
||||
93
lib/dateutil/test/test_easter.py
Normal file
93
lib/dateutil/test/test_easter.py
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
from dateutil.easter import easter
|
||||
from dateutil.easter import EASTER_WESTERN, EASTER_ORTHODOX, EASTER_JULIAN
|
||||
|
||||
from datetime import date
|
||||
import pytest
|
||||
|
||||
# List of easters between 1990 and 2050
|
||||
western_easter_dates = [
|
||||
date(1990, 4, 15), date(1991, 3, 31), date(1992, 4, 19), date(1993, 4, 11),
|
||||
date(1994, 4, 3), date(1995, 4, 16), date(1996, 4, 7), date(1997, 3, 30),
|
||||
date(1998, 4, 12), date(1999, 4, 4),
|
||||
|
||||
date(2000, 4, 23), date(2001, 4, 15), date(2002, 3, 31), date(2003, 4, 20),
|
||||
date(2004, 4, 11), date(2005, 3, 27), date(2006, 4, 16), date(2007, 4, 8),
|
||||
date(2008, 3, 23), date(2009, 4, 12),
|
||||
|
||||
date(2010, 4, 4), date(2011, 4, 24), date(2012, 4, 8), date(2013, 3, 31),
|
||||
date(2014, 4, 20), date(2015, 4, 5), date(2016, 3, 27), date(2017, 4, 16),
|
||||
date(2018, 4, 1), date(2019, 4, 21),
|
||||
|
||||
date(2020, 4, 12), date(2021, 4, 4), date(2022, 4, 17), date(2023, 4, 9),
|
||||
date(2024, 3, 31), date(2025, 4, 20), date(2026, 4, 5), date(2027, 3, 28),
|
||||
date(2028, 4, 16), date(2029, 4, 1),
|
||||
|
||||
date(2030, 4, 21), date(2031, 4, 13), date(2032, 3, 28), date(2033, 4, 17),
|
||||
date(2034, 4, 9), date(2035, 3, 25), date(2036, 4, 13), date(2037, 4, 5),
|
||||
date(2038, 4, 25), date(2039, 4, 10),
|
||||
|
||||
date(2040, 4, 1), date(2041, 4, 21), date(2042, 4, 6), date(2043, 3, 29),
|
||||
date(2044, 4, 17), date(2045, 4, 9), date(2046, 3, 25), date(2047, 4, 14),
|
||||
date(2048, 4, 5), date(2049, 4, 18), date(2050, 4, 10)
|
||||
]
|
||||
|
||||
orthodox_easter_dates = [
|
||||
date(1990, 4, 15), date(1991, 4, 7), date(1992, 4, 26), date(1993, 4, 18),
|
||||
date(1994, 5, 1), date(1995, 4, 23), date(1996, 4, 14), date(1997, 4, 27),
|
||||
date(1998, 4, 19), date(1999, 4, 11),
|
||||
|
||||
date(2000, 4, 30), date(2001, 4, 15), date(2002, 5, 5), date(2003, 4, 27),
|
||||
date(2004, 4, 11), date(2005, 5, 1), date(2006, 4, 23), date(2007, 4, 8),
|
||||
date(2008, 4, 27), date(2009, 4, 19),
|
||||
|
||||
date(2010, 4, 4), date(2011, 4, 24), date(2012, 4, 15), date(2013, 5, 5),
|
||||
date(2014, 4, 20), date(2015, 4, 12), date(2016, 5, 1), date(2017, 4, 16),
|
||||
date(2018, 4, 8), date(2019, 4, 28),
|
||||
|
||||
date(2020, 4, 19), date(2021, 5, 2), date(2022, 4, 24), date(2023, 4, 16),
|
||||
date(2024, 5, 5), date(2025, 4, 20), date(2026, 4, 12), date(2027, 5, 2),
|
||||
date(2028, 4, 16), date(2029, 4, 8),
|
||||
|
||||
date(2030, 4, 28), date(2031, 4, 13), date(2032, 5, 2), date(2033, 4, 24),
|
||||
date(2034, 4, 9), date(2035, 4, 29), date(2036, 4, 20), date(2037, 4, 5),
|
||||
date(2038, 4, 25), date(2039, 4, 17),
|
||||
|
||||
date(2040, 5, 6), date(2041, 4, 21), date(2042, 4, 13), date(2043, 5, 3),
|
||||
date(2044, 4, 24), date(2045, 4, 9), date(2046, 4, 29), date(2047, 4, 21),
|
||||
date(2048, 4, 5), date(2049, 4, 25), date(2050, 4, 17)
|
||||
]
|
||||
|
||||
# A random smattering of Julian dates.
|
||||
# Pulled values from http://www.kevinlaughery.com/east4099.html
|
||||
julian_easter_dates = [
|
||||
date( 326, 4, 3), date( 375, 4, 5), date( 492, 4, 5), date( 552, 3, 31),
|
||||
date( 562, 4, 9), date( 569, 4, 21), date( 597, 4, 14), date( 621, 4, 19),
|
||||
date( 636, 3, 31), date( 655, 3, 29), date( 700, 4, 11), date( 725, 4, 8),
|
||||
date( 750, 3, 29), date( 782, 4, 7), date( 835, 4, 18), date( 849, 4, 14),
|
||||
date( 867, 3, 30), date( 890, 4, 12), date( 922, 4, 21), date( 934, 4, 6),
|
||||
date(1049, 3, 26), date(1058, 4, 19), date(1113, 4, 6), date(1119, 3, 30),
|
||||
date(1242, 4, 20), date(1255, 3, 28), date(1257, 4, 8), date(1258, 3, 24),
|
||||
date(1261, 4, 24), date(1278, 4, 17), date(1333, 4, 4), date(1351, 4, 17),
|
||||
date(1371, 4, 6), date(1391, 3, 26), date(1402, 3, 26), date(1412, 4, 3),
|
||||
date(1439, 4, 5), date(1445, 3, 28), date(1531, 4, 9), date(1555, 4, 14)
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("easter_date", western_easter_dates)
|
||||
def test_easter_western(easter_date):
|
||||
assert easter_date == easter(easter_date.year, EASTER_WESTERN)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("easter_date", orthodox_easter_dates)
|
||||
def test_easter_orthodox(easter_date):
|
||||
assert easter_date == easter(easter_date.year, EASTER_ORTHODOX)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("easter_date", julian_easter_dates)
|
||||
def test_easter_julian(easter_date):
|
||||
assert easter_date == easter(easter_date.year, EASTER_JULIAN)
|
||||
|
||||
|
||||
def test_easter_bad_method():
|
||||
with pytest.raises(ValueError):
|
||||
easter(1975, 4)
|
||||
33
lib/dateutil/test/test_import_star.py
Normal file
33
lib/dateutil/test/test_import_star.py
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
"""Test for the "import *" functionality.
|
||||
|
||||
As import * can be only done at module level, it has been added in a separate file
|
||||
"""
|
||||
import pytest
|
||||
|
||||
prev_locals = list(locals())
|
||||
from dateutil import *
|
||||
new_locals = {name:value for name,value in locals().items()
|
||||
if name not in prev_locals}
|
||||
new_locals.pop('prev_locals')
|
||||
|
||||
|
||||
@pytest.mark.import_star
|
||||
def test_imported_modules():
|
||||
""" Test that `from dateutil import *` adds modules in __all__ locally """
|
||||
import dateutil.easter
|
||||
import dateutil.parser
|
||||
import dateutil.relativedelta
|
||||
import dateutil.rrule
|
||||
import dateutil.tz
|
||||
import dateutil.utils
|
||||
import dateutil.zoneinfo
|
||||
|
||||
assert dateutil.easter == new_locals.pop("easter")
|
||||
assert dateutil.parser == new_locals.pop("parser")
|
||||
assert dateutil.relativedelta == new_locals.pop("relativedelta")
|
||||
assert dateutil.rrule == new_locals.pop("rrule")
|
||||
assert dateutil.tz == new_locals.pop("tz")
|
||||
assert dateutil.utils == new_locals.pop("utils")
|
||||
assert dateutil.zoneinfo == new_locals.pop("zoneinfo")
|
||||
|
||||
assert not new_locals
|
||||
176
lib/dateutil/test/test_imports.py
Normal file
176
lib/dateutil/test/test_imports.py
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
import sys
|
||||
import pytest
|
||||
|
||||
|
||||
HOST_IS_WINDOWS = sys.platform.startswith('win')
|
||||
|
||||
|
||||
def test_import_version_str():
|
||||
""" Test that dateutil.__version__ can be imported"""
|
||||
from dateutil import __version__
|
||||
|
||||
|
||||
def test_import_version_root():
|
||||
import dateutil
|
||||
assert hasattr(dateutil, '__version__')
|
||||
|
||||
|
||||
# Test that dateutil.easter-related imports work properly
|
||||
def test_import_easter_direct():
|
||||
import dateutil.easter
|
||||
|
||||
|
||||
def test_import_easter_from():
|
||||
from dateutil import easter
|
||||
|
||||
|
||||
def test_import_easter_start():
|
||||
from dateutil.easter import easter
|
||||
|
||||
|
||||
# Test that dateutil.parser-related imports work properly
|
||||
def test_import_parser_direct():
|
||||
import dateutil.parser
|
||||
|
||||
|
||||
def test_import_parser_from():
|
||||
from dateutil import parser
|
||||
|
||||
|
||||
def test_import_parser_all():
|
||||
# All interface
|
||||
from dateutil.parser import parse
|
||||
from dateutil.parser import parserinfo
|
||||
|
||||
# Other public classes
|
||||
from dateutil.parser import parser
|
||||
|
||||
for var in (parse, parserinfo, parser):
|
||||
assert var is not None
|
||||
|
||||
|
||||
# Test that dateutil.relativedelta-related imports work properly
|
||||
def test_import_relative_delta_direct():
|
||||
import dateutil.relativedelta
|
||||
|
||||
|
||||
def test_import_relative_delta_from():
|
||||
from dateutil import relativedelta
|
||||
|
||||
def test_import_relative_delta_all():
|
||||
from dateutil.relativedelta import relativedelta
|
||||
from dateutil.relativedelta import MO, TU, WE, TH, FR, SA, SU
|
||||
|
||||
for var in (relativedelta, MO, TU, WE, TH, FR, SA, SU):
|
||||
assert var is not None
|
||||
|
||||
# In the public interface but not in all
|
||||
from dateutil.relativedelta import weekday
|
||||
assert weekday is not None
|
||||
|
||||
|
||||
# Test that dateutil.rrule related imports work properly
|
||||
def test_import_rrule_direct():
|
||||
import dateutil.rrule
|
||||
|
||||
|
||||
def test_import_rrule_from():
|
||||
from dateutil import rrule
|
||||
|
||||
|
||||
def test_import_rrule_all():
|
||||
from dateutil.rrule import rrule
|
||||
from dateutil.rrule import rruleset
|
||||
from dateutil.rrule import rrulestr
|
||||
from dateutil.rrule import YEARLY, MONTHLY, WEEKLY, DAILY
|
||||
from dateutil.rrule import HOURLY, MINUTELY, SECONDLY
|
||||
from dateutil.rrule import MO, TU, WE, TH, FR, SA, SU
|
||||
|
||||
rr_all = (rrule, rruleset, rrulestr,
|
||||
YEARLY, MONTHLY, WEEKLY, DAILY,
|
||||
HOURLY, MINUTELY, SECONDLY,
|
||||
MO, TU, WE, TH, FR, SA, SU)
|
||||
|
||||
for var in rr_all:
|
||||
assert var is not None
|
||||
|
||||
# In the public interface but not in all
|
||||
from dateutil.rrule import weekday
|
||||
assert weekday is not None
|
||||
|
||||
|
||||
# Test that dateutil.tz related imports work properly
|
||||
def test_import_tztest_direct():
|
||||
import dateutil.tz
|
||||
|
||||
|
||||
def test_import_tz_from():
|
||||
from dateutil import tz
|
||||
|
||||
|
||||
def test_import_tz_all():
|
||||
from dateutil.tz import tzutc
|
||||
from dateutil.tz import tzoffset
|
||||
from dateutil.tz import tzlocal
|
||||
from dateutil.tz import tzfile
|
||||
from dateutil.tz import tzrange
|
||||
from dateutil.tz import tzstr
|
||||
from dateutil.tz import tzical
|
||||
from dateutil.tz import gettz
|
||||
from dateutil.tz import tzwin
|
||||
from dateutil.tz import tzwinlocal
|
||||
from dateutil.tz import UTC
|
||||
from dateutil.tz import datetime_ambiguous
|
||||
from dateutil.tz import datetime_exists
|
||||
from dateutil.tz import resolve_imaginary
|
||||
|
||||
tz_all = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
|
||||
"tzstr", "tzical", "gettz", "datetime_ambiguous",
|
||||
"datetime_exists", "resolve_imaginary", "UTC"]
|
||||
|
||||
tz_all += ["tzwin", "tzwinlocal"] if sys.platform.startswith("win") else []
|
||||
lvars = locals()
|
||||
|
||||
for var in tz_all:
|
||||
assert lvars[var] is not None
|
||||
|
||||
# Test that dateutil.tzwin related imports work properly
|
||||
@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
|
||||
def test_import_tz_windows_direct():
|
||||
import dateutil.tzwin
|
||||
|
||||
|
||||
@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
|
||||
def test_import_tz_windows_from():
|
||||
from dateutil import tzwin
|
||||
|
||||
|
||||
@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
|
||||
def test_import_tz_windows_star():
|
||||
from dateutil.tzwin import tzwin
|
||||
from dateutil.tzwin import tzwinlocal
|
||||
|
||||
tzwin_all = [tzwin, tzwinlocal]
|
||||
|
||||
for var in tzwin_all:
|
||||
assert var is not None
|
||||
|
||||
|
||||
# Test imports of Zone Info
|
||||
def test_import_zone_info_direct():
|
||||
import dateutil.zoneinfo
|
||||
|
||||
|
||||
def test_import_zone_info_from():
|
||||
from dateutil import zoneinfo
|
||||
|
||||
|
||||
def test_import_zone_info_star():
|
||||
from dateutil.zoneinfo import gettz
|
||||
from dateutil.zoneinfo import gettz_db_metadata
|
||||
from dateutil.zoneinfo import rebuild
|
||||
|
||||
zi_all = (gettz, gettz_db_metadata, rebuild)
|
||||
|
||||
for var in zi_all:
|
||||
assert var is not None
|
||||
91
lib/dateutil/test/test_internals.py
Normal file
91
lib/dateutil/test/test_internals.py
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Tests for implementation details, not necessarily part of the user-facing
|
||||
API.
|
||||
|
||||
The motivating case for these tests is #483, where we want to smoke-test
|
||||
code that may be difficult to reach through the standard API calls.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
from dateutil.parser._parser import _ymd
|
||||
from dateutil import tz
|
||||
|
||||
IS_PY32 = sys.version_info[0:2] == (3, 2)
|
||||
|
||||
|
||||
@pytest.mark.smoke
|
||||
def test_YMD_could_be_day():
|
||||
ymd = _ymd('foo bar 124 baz')
|
||||
|
||||
ymd.append(2, 'M')
|
||||
assert ymd.has_month
|
||||
assert not ymd.has_year
|
||||
assert ymd.could_be_day(4)
|
||||
assert not ymd.could_be_day(-6)
|
||||
assert not ymd.could_be_day(32)
|
||||
|
||||
# Assumes leap year
|
||||
assert ymd.could_be_day(29)
|
||||
|
||||
ymd.append(1999)
|
||||
assert ymd.has_year
|
||||
assert not ymd.could_be_day(29)
|
||||
|
||||
ymd.append(16, 'D')
|
||||
assert ymd.has_day
|
||||
assert not ymd.could_be_day(1)
|
||||
|
||||
ymd = _ymd('foo bar 124 baz')
|
||||
ymd.append(1999)
|
||||
assert ymd.could_be_day(31)
|
||||
|
||||
|
||||
###
|
||||
# Test that private interfaces in _parser are deprecated properly
|
||||
@pytest.mark.skipif(IS_PY32, reason='pytest.warns not supported on Python 3.2')
|
||||
def test_parser_private_warns():
|
||||
from dateutil.parser import _timelex, _tzparser
|
||||
from dateutil.parser import _parsetz
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
_tzparser()
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
_timelex('2014-03-03')
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
_parsetz('+05:00')
|
||||
|
||||
|
||||
@pytest.mark.skipif(IS_PY32, reason='pytest.warns not supported on Python 3.2')
|
||||
def test_parser_parser_private_not_warns():
|
||||
from dateutil.parser._parser import _timelex, _tzparser
|
||||
from dateutil.parser._parser import _parsetz
|
||||
|
||||
with pytest.warns(None) as recorder:
|
||||
_tzparser()
|
||||
assert len(recorder) == 0
|
||||
|
||||
with pytest.warns(None) as recorder:
|
||||
_timelex('2014-03-03')
|
||||
|
||||
assert len(recorder) == 0
|
||||
|
||||
with pytest.warns(None) as recorder:
|
||||
_parsetz('+05:00')
|
||||
assert len(recorder) == 0
|
||||
|
||||
|
||||
@pytest.mark.tzstr
|
||||
def test_tzstr_internal_timedeltas():
|
||||
with pytest.warns(tz.DeprecatedTzFormatWarning):
|
||||
tz1 = tz.tzstr("EST5EDT,5,4,0,7200,11,-3,0,7200")
|
||||
|
||||
with pytest.warns(tz.DeprecatedTzFormatWarning):
|
||||
tz2 = tz.tzstr("EST5EDT,4,1,0,7200,10,-1,0,7200")
|
||||
|
||||
assert tz1._start_delta != tz2._start_delta
|
||||
assert tz1._end_delta != tz2._end_delta
|
||||
509
lib/dateutil/test/test_isoparser.py
Normal file
509
lib/dateutil/test/test_isoparser.py
Normal file
|
|
@ -0,0 +1,509 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from datetime import datetime, timedelta, date, time
|
||||
import itertools as it
|
||||
|
||||
from dateutil import tz
|
||||
from dateutil.tz import UTC
|
||||
from dateutil.parser import isoparser, isoparse
|
||||
|
||||
import pytest
|
||||
import six
|
||||
|
||||
|
||||
def _generate_tzoffsets(limited):
|
||||
def _mkoffset(hmtuple, fmt):
|
||||
h, m = hmtuple
|
||||
m_td = (-1 if h < 0 else 1) * m
|
||||
|
||||
tzo = tz.tzoffset(None, timedelta(hours=h, minutes=m_td))
|
||||
return tzo, fmt.format(h, m)
|
||||
|
||||
out = []
|
||||
if not limited:
|
||||
# The subset that's just hours
|
||||
hm_out_h = [(h, 0) for h in (-23, -5, 0, 5, 23)]
|
||||
out.extend([_mkoffset(hm, '{:+03d}') for hm in hm_out_h])
|
||||
|
||||
# Ones that have hours and minutes
|
||||
hm_out = [] + hm_out_h
|
||||
hm_out += [(-12, 15), (11, 30), (10, 2), (5, 15), (-5, 30)]
|
||||
else:
|
||||
hm_out = [(-5, -0)]
|
||||
|
||||
fmts = ['{:+03d}:{:02d}', '{:+03d}{:02d}']
|
||||
out += [_mkoffset(hm, fmt) for hm in hm_out for fmt in fmts]
|
||||
|
||||
# Also add in UTC and naive
|
||||
out.append((UTC, 'Z'))
|
||||
out.append((None, ''))
|
||||
|
||||
return out
|
||||
|
||||
FULL_TZOFFSETS = _generate_tzoffsets(False)
|
||||
FULL_TZOFFSETS_AWARE = [x for x in FULL_TZOFFSETS if x[1]]
|
||||
TZOFFSETS = _generate_tzoffsets(True)
|
||||
|
||||
DATES = [datetime(1996, 1, 1), datetime(2017, 1, 1)]
|
||||
@pytest.mark.parametrize('dt', tuple(DATES))
|
||||
def test_year_only(dt):
|
||||
dtstr = dt.strftime('%Y')
|
||||
|
||||
assert isoparse(dtstr) == dt
|
||||
|
||||
DATES += [datetime(2000, 2, 1), datetime(2017, 4, 1)]
|
||||
@pytest.mark.parametrize('dt', tuple(DATES))
|
||||
def test_year_month(dt):
|
||||
fmt = '%Y-%m'
|
||||
dtstr = dt.strftime(fmt)
|
||||
|
||||
assert isoparse(dtstr) == dt
|
||||
|
||||
DATES += [datetime(2016, 2, 29), datetime(2018, 3, 15)]
|
||||
YMD_FMTS = ('%Y%m%d', '%Y-%m-%d')
|
||||
@pytest.mark.parametrize('dt', tuple(DATES))
|
||||
@pytest.mark.parametrize('fmt', YMD_FMTS)
|
||||
def test_year_month_day(dt, fmt):
|
||||
dtstr = dt.strftime(fmt)
|
||||
|
||||
assert isoparse(dtstr) == dt
|
||||
|
||||
def _isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset,
|
||||
microsecond_precision=None):
|
||||
tzi, offset_str = tzoffset
|
||||
fmt = date_fmt + 'T' + time_fmt
|
||||
dt = dt.replace(tzinfo=tzi)
|
||||
dtstr = dt.strftime(fmt)
|
||||
|
||||
if microsecond_precision is not None:
|
||||
if not fmt.endswith('%f'): # pragma: nocover
|
||||
raise ValueError('Time format has no microseconds!')
|
||||
|
||||
if microsecond_precision != 6:
|
||||
dtstr = dtstr[:-(6 - microsecond_precision)]
|
||||
elif microsecond_precision > 6: # pragma: nocover
|
||||
raise ValueError('Precision must be 1-6')
|
||||
|
||||
dtstr += offset_str
|
||||
|
||||
assert isoparse(dtstr) == dt
|
||||
|
||||
DATETIMES = [datetime(1998, 4, 16, 12),
|
||||
datetime(2019, 11, 18, 23),
|
||||
datetime(2014, 12, 16, 4)]
|
||||
@pytest.mark.parametrize('dt', tuple(DATETIMES))
|
||||
@pytest.mark.parametrize('date_fmt', YMD_FMTS)
|
||||
@pytest.mark.parametrize('tzoffset', TZOFFSETS)
|
||||
def test_ymd_h(dt, date_fmt, tzoffset):
|
||||
_isoparse_date_and_time(dt, date_fmt, '%H', tzoffset)
|
||||
|
||||
DATETIMES = [datetime(2012, 1, 6, 9, 37)]
|
||||
@pytest.mark.parametrize('dt', tuple(DATETIMES))
|
||||
@pytest.mark.parametrize('date_fmt', YMD_FMTS)
|
||||
@pytest.mark.parametrize('time_fmt', ('%H%M', '%H:%M'))
|
||||
@pytest.mark.parametrize('tzoffset', TZOFFSETS)
|
||||
def test_ymd_hm(dt, date_fmt, time_fmt, tzoffset):
|
||||
_isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset)
|
||||
|
||||
DATETIMES = [datetime(2003, 9, 2, 22, 14, 2),
|
||||
datetime(2003, 8, 8, 14, 9, 14),
|
||||
datetime(2003, 4, 7, 6, 14, 59)]
|
||||
HMS_FMTS = ('%H%M%S', '%H:%M:%S')
|
||||
@pytest.mark.parametrize('dt', tuple(DATETIMES))
|
||||
@pytest.mark.parametrize('date_fmt', YMD_FMTS)
|
||||
@pytest.mark.parametrize('time_fmt', HMS_FMTS)
|
||||
@pytest.mark.parametrize('tzoffset', TZOFFSETS)
|
||||
def test_ymd_hms(dt, date_fmt, time_fmt, tzoffset):
|
||||
_isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset)
|
||||
|
||||
DATETIMES = [datetime(2017, 11, 27, 6, 14, 30, 123456)]
|
||||
@pytest.mark.parametrize('dt', tuple(DATETIMES))
|
||||
@pytest.mark.parametrize('date_fmt', YMD_FMTS)
|
||||
@pytest.mark.parametrize('time_fmt', (x + sep + '%f' for x in HMS_FMTS
|
||||
for sep in '.,'))
|
||||
@pytest.mark.parametrize('tzoffset', TZOFFSETS)
|
||||
@pytest.mark.parametrize('precision', list(range(3, 7)))
|
||||
def test_ymd_hms_micro(dt, date_fmt, time_fmt, tzoffset, precision):
|
||||
# Truncate the microseconds to the desired precision for the representation
|
||||
dt = dt.replace(microsecond=int(round(dt.microsecond, precision-6)))
|
||||
|
||||
_isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset, precision)
|
||||
|
||||
###
|
||||
# Truncation of extra digits beyond microsecond precision
|
||||
@pytest.mark.parametrize('dt_str', [
|
||||
'2018-07-03T14:07:00.123456000001',
|
||||
'2018-07-03T14:07:00.123456999999',
|
||||
])
|
||||
def test_extra_subsecond_digits(dt_str):
|
||||
assert isoparse(dt_str) == datetime(2018, 7, 3, 14, 7, 0, 123456)
|
||||
|
||||
@pytest.mark.parametrize('tzoffset', FULL_TZOFFSETS)
|
||||
def test_full_tzoffsets(tzoffset):
|
||||
dt = datetime(2017, 11, 27, 6, 14, 30, 123456)
|
||||
date_fmt = '%Y-%m-%d'
|
||||
time_fmt = '%H:%M:%S.%f'
|
||||
|
||||
_isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset)
|
||||
|
||||
@pytest.mark.parametrize('dt_str', [
|
||||
'2014-04-11T00',
|
||||
'2014-04-10T24',
|
||||
'2014-04-11T00:00',
|
||||
'2014-04-10T24:00',
|
||||
'2014-04-11T00:00:00',
|
||||
'2014-04-10T24:00:00',
|
||||
'2014-04-11T00:00:00.000',
|
||||
'2014-04-10T24:00:00.000',
|
||||
'2014-04-11T00:00:00.000000',
|
||||
'2014-04-10T24:00:00.000000']
|
||||
)
|
||||
def test_datetime_midnight(dt_str):
|
||||
assert isoparse(dt_str) == datetime(2014, 4, 11, 0, 0, 0, 0)
|
||||
|
||||
@pytest.mark.parametrize('datestr', [
|
||||
'2014-01-01',
|
||||
'20140101',
|
||||
])
|
||||
@pytest.mark.parametrize('sep', [' ', 'a', 'T', '_', '-'])
|
||||
def test_isoparse_sep_none(datestr, sep):
|
||||
isostr = datestr + sep + '14:33:09'
|
||||
assert isoparse(isostr) == datetime(2014, 1, 1, 14, 33, 9)
|
||||
|
||||
##
|
||||
# Uncommon date formats
|
||||
TIME_ARGS = ('time_args',
|
||||
((None, time(0), None), ) + tuple(('%H:%M:%S.%f', _t, _tz)
|
||||
for _t, _tz in it.product([time(0), time(9, 30), time(14, 47)],
|
||||
TZOFFSETS)))
|
||||
|
||||
@pytest.mark.parametrize('isocal,dt_expected',[
|
||||
((2017, 10), datetime(2017, 3, 6)),
|
||||
((2020, 1), datetime(2019, 12, 30)), # ISO year != Cal year
|
||||
((2004, 53), datetime(2004, 12, 27)), # Only half the week is in 2014
|
||||
])
|
||||
def test_isoweek(isocal, dt_expected):
|
||||
# TODO: Figure out how to parametrize this on formats, too
|
||||
for fmt in ('{:04d}-W{:02d}', '{:04d}W{:02d}'):
|
||||
dtstr = fmt.format(*isocal)
|
||||
assert isoparse(dtstr) == dt_expected
|
||||
|
||||
@pytest.mark.parametrize('isocal,dt_expected',[
|
||||
((2016, 13, 7), datetime(2016, 4, 3)),
|
||||
((2004, 53, 7), datetime(2005, 1, 2)), # ISO year != Cal year
|
||||
((2009, 1, 2), datetime(2008, 12, 30)), # ISO year < Cal year
|
||||
((2009, 53, 6), datetime(2010, 1, 2)) # ISO year > Cal year
|
||||
])
|
||||
def test_isoweek_day(isocal, dt_expected):
|
||||
# TODO: Figure out how to parametrize this on formats, too
|
||||
for fmt in ('{:04d}-W{:02d}-{:d}', '{:04d}W{:02d}{:d}'):
|
||||
dtstr = fmt.format(*isocal)
|
||||
assert isoparse(dtstr) == dt_expected
|
||||
|
||||
@pytest.mark.parametrize('isoord,dt_expected', [
|
||||
((2004, 1), datetime(2004, 1, 1)),
|
||||
((2016, 60), datetime(2016, 2, 29)),
|
||||
((2017, 60), datetime(2017, 3, 1)),
|
||||
((2016, 366), datetime(2016, 12, 31)),
|
||||
((2017, 365), datetime(2017, 12, 31))
|
||||
])
|
||||
def test_iso_ordinal(isoord, dt_expected):
|
||||
for fmt in ('{:04d}-{:03d}', '{:04d}{:03d}'):
|
||||
dtstr = fmt.format(*isoord)
|
||||
|
||||
assert isoparse(dtstr) == dt_expected
|
||||
|
||||
|
||||
###
|
||||
# Acceptance of bytes
|
||||
@pytest.mark.parametrize('isostr,dt', [
|
||||
(b'2014', datetime(2014, 1, 1)),
|
||||
(b'20140204', datetime(2014, 2, 4)),
|
||||
(b'2014-02-04', datetime(2014, 2, 4)),
|
||||
(b'2014-02-04T12', datetime(2014, 2, 4, 12)),
|
||||
(b'2014-02-04T12:30', datetime(2014, 2, 4, 12, 30)),
|
||||
(b'2014-02-04T12:30:15', datetime(2014, 2, 4, 12, 30, 15)),
|
||||
(b'2014-02-04T12:30:15.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
|
||||
(b'20140204T123015.224', datetime(2014, 2, 4, 12, 30, 15, 224000)),
|
||||
(b'2014-02-04T12:30:15.224Z', datetime(2014, 2, 4, 12, 30, 15, 224000,
|
||||
UTC)),
|
||||
(b'2014-02-04T12:30:15.224z', datetime(2014, 2, 4, 12, 30, 15, 224000,
|
||||
UTC)),
|
||||
(b'2014-02-04T12:30:15.224+05:00',
|
||||
datetime(2014, 2, 4, 12, 30, 15, 224000,
|
||||
tzinfo=tz.tzoffset(None, timedelta(hours=5))))])
|
||||
def test_bytes(isostr, dt):
|
||||
assert isoparse(isostr) == dt
|
||||
|
||||
|
||||
###
|
||||
# Invalid ISO strings
|
||||
@pytest.mark.parametrize('isostr,exception', [
|
||||
('201', ValueError), # ISO string too short
|
||||
('2012-0425', ValueError), # Inconsistent date separators
|
||||
('201204-25', ValueError), # Inconsistent date separators
|
||||
('20120425T0120:00', ValueError), # Inconsistent time separators
|
||||
('20120425T01:2000', ValueError), # Inconsistent time separators
|
||||
('14:3015', ValueError), # Inconsistent time separator
|
||||
('20120425T012500-334', ValueError), # Wrong microsecond separator
|
||||
('2001-1', ValueError), # YYYY-M not valid
|
||||
('2012-04-9', ValueError), # YYYY-MM-D not valid
|
||||
('201204', ValueError), # YYYYMM not valid
|
||||
('20120411T03:30+', ValueError), # Time zone too short
|
||||
('20120411T03:30+1234567', ValueError), # Time zone too long
|
||||
('20120411T03:30-25:40', ValueError), # Time zone invalid
|
||||
('2012-1a', ValueError), # Invalid month
|
||||
('20120411T03:30+00:60', ValueError), # Time zone invalid minutes
|
||||
('20120411T03:30+00:61', ValueError), # Time zone invalid minutes
|
||||
('20120411T033030.123456012:00', # No sign in time zone
|
||||
ValueError),
|
||||
('2012-W00', ValueError), # Invalid ISO week
|
||||
('2012-W55', ValueError), # Invalid ISO week
|
||||
('2012-W01-0', ValueError), # Invalid ISO week day
|
||||
('2012-W01-8', ValueError), # Invalid ISO week day
|
||||
('2013-000', ValueError), # Invalid ordinal day
|
||||
('2013-366', ValueError), # Invalid ordinal day
|
||||
('2013366', ValueError), # Invalid ordinal day
|
||||
('2014-03-12Т12:30:14', ValueError), # Cyrillic T
|
||||
('2014-04-21T24:00:01', ValueError), # Invalid use of 24 for midnight
|
||||
('2014_W01-1', ValueError), # Invalid separator
|
||||
('2014W01-1', ValueError), # Inconsistent use of dashes
|
||||
('2014-W011', ValueError), # Inconsistent use of dashes
|
||||
|
||||
])
|
||||
def test_iso_raises(isostr, exception):
|
||||
with pytest.raises(exception):
|
||||
isoparse(isostr)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('sep_act, valid_sep, exception', [
|
||||
('T', 'C', ValueError),
|
||||
('C', 'T', ValueError),
|
||||
])
|
||||
def test_iso_with_sep_raises(sep_act, valid_sep, exception):
|
||||
parser = isoparser(sep=valid_sep)
|
||||
isostr = '2012-04-25' + sep_act + '01:25:00'
|
||||
with pytest.raises(exception):
|
||||
parser.isoparse(isostr)
|
||||
|
||||
|
||||
###
|
||||
# Test ISOParser constructor
|
||||
@pytest.mark.parametrize('sep', [' ', '9', '🍛'])
|
||||
def test_isoparser_invalid_sep(sep):
|
||||
with pytest.raises(ValueError):
|
||||
isoparser(sep=sep)
|
||||
|
||||
|
||||
# This only fails on Python 3
|
||||
@pytest.mark.xfail(not six.PY2, reason="Fails on Python 3 only")
|
||||
def test_isoparser_byte_sep():
|
||||
dt = datetime(2017, 12, 6, 12, 30, 45)
|
||||
dt_str = dt.isoformat(sep=str('T'))
|
||||
|
||||
dt_rt = isoparser(sep=b'T').isoparse(dt_str)
|
||||
|
||||
assert dt == dt_rt
|
||||
|
||||
|
||||
###
|
||||
# Test parse_tzstr
|
||||
@pytest.mark.parametrize('tzoffset', FULL_TZOFFSETS)
|
||||
def test_parse_tzstr(tzoffset):
|
||||
dt = datetime(2017, 11, 27, 6, 14, 30, 123456)
|
||||
date_fmt = '%Y-%m-%d'
|
||||
time_fmt = '%H:%M:%S.%f'
|
||||
|
||||
_isoparse_date_and_time(dt, date_fmt, time_fmt, tzoffset)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('tzstr', [
|
||||
'-00:00', '+00:00', '+00', '-00', '+0000', '-0000'
|
||||
])
|
||||
@pytest.mark.parametrize('zero_as_utc', [True, False])
|
||||
def test_parse_tzstr_zero_as_utc(tzstr, zero_as_utc):
|
||||
tzi = isoparser().parse_tzstr(tzstr, zero_as_utc=zero_as_utc)
|
||||
assert tzi == UTC
|
||||
assert (type(tzi) == tz.tzutc) == zero_as_utc
|
||||
|
||||
|
||||
@pytest.mark.parametrize('tzstr,exception', [
|
||||
('00:00', ValueError), # No sign
|
||||
('05:00', ValueError), # No sign
|
||||
('_00:00', ValueError), # Invalid sign
|
||||
('+25:00', ValueError), # Offset too large
|
||||
('00:0000', ValueError), # String too long
|
||||
])
|
||||
def test_parse_tzstr_fails(tzstr, exception):
|
||||
with pytest.raises(exception):
|
||||
isoparser().parse_tzstr(tzstr)
|
||||
|
||||
###
|
||||
# Test parse_isodate
|
||||
def __make_date_examples():
|
||||
dates_no_day = [
|
||||
date(1999, 12, 1),
|
||||
date(2016, 2, 1)
|
||||
]
|
||||
|
||||
if not six.PY2:
|
||||
# strftime does not support dates before 1900 in Python 2
|
||||
dates_no_day.append(date(1000, 11, 1))
|
||||
|
||||
# Only one supported format for dates with no day
|
||||
o = zip(dates_no_day, it.repeat('%Y-%m'))
|
||||
|
||||
dates_w_day = [
|
||||
date(1969, 12, 31),
|
||||
date(1900, 1, 1),
|
||||
date(2016, 2, 29),
|
||||
date(2017, 11, 14)
|
||||
]
|
||||
|
||||
dates_w_day_fmts = ('%Y%m%d', '%Y-%m-%d')
|
||||
o = it.chain(o, it.product(dates_w_day, dates_w_day_fmts))
|
||||
|
||||
return list(o)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('d,dt_fmt', __make_date_examples())
|
||||
@pytest.mark.parametrize('as_bytes', [True, False])
|
||||
def test_parse_isodate(d, dt_fmt, as_bytes):
|
||||
d_str = d.strftime(dt_fmt)
|
||||
if isinstance(d_str, six.text_type) and as_bytes:
|
||||
d_str = d_str.encode('ascii')
|
||||
elif isinstance(d_str, bytes) and not as_bytes:
|
||||
d_str = d_str.decode('ascii')
|
||||
|
||||
iparser = isoparser()
|
||||
assert iparser.parse_isodate(d_str) == d
|
||||
|
||||
|
||||
@pytest.mark.parametrize('isostr,exception', [
|
||||
('243', ValueError), # ISO string too short
|
||||
('2014-0423', ValueError), # Inconsistent date separators
|
||||
('201404-23', ValueError), # Inconsistent date separators
|
||||
('2014日03月14', ValueError), # Not ASCII
|
||||
('2013-02-29', ValueError), # Not a leap year
|
||||
('2014/12/03', ValueError), # Wrong separators
|
||||
('2014-04-19T', ValueError), # Unknown components
|
||||
('201202', ValueError), # Invalid format
|
||||
])
|
||||
def test_isodate_raises(isostr, exception):
|
||||
with pytest.raises(exception):
|
||||
isoparser().parse_isodate(isostr)
|
||||
|
||||
|
||||
def test_parse_isodate_error_text():
|
||||
with pytest.raises(ValueError) as excinfo:
|
||||
isoparser().parse_isodate('2014-0423')
|
||||
|
||||
# ensure the error message does not contain b' prefixes
|
||||
if six.PY2:
|
||||
expected_error = "String contains unknown ISO components: u'2014-0423'"
|
||||
else:
|
||||
expected_error = "String contains unknown ISO components: '2014-0423'"
|
||||
assert expected_error == str(excinfo.value)
|
||||
|
||||
|
||||
###
|
||||
# Test parse_isotime
|
||||
def __make_time_examples():
|
||||
outputs = []
|
||||
|
||||
# HH
|
||||
time_h = [time(0), time(8), time(22)]
|
||||
time_h_fmts = ['%H']
|
||||
|
||||
outputs.append(it.product(time_h, time_h_fmts))
|
||||
|
||||
# HHMM / HH:MM
|
||||
time_hm = [time(0, 0), time(0, 30), time(8, 47), time(16, 1)]
|
||||
time_hm_fmts = ['%H%M', '%H:%M']
|
||||
|
||||
outputs.append(it.product(time_hm, time_hm_fmts))
|
||||
|
||||
# HHMMSS / HH:MM:SS
|
||||
time_hms = [time(0, 0, 0), time(0, 15, 30),
|
||||
time(8, 2, 16), time(12, 0), time(16, 2), time(20, 45)]
|
||||
|
||||
time_hms_fmts = ['%H%M%S', '%H:%M:%S']
|
||||
|
||||
outputs.append(it.product(time_hms, time_hms_fmts))
|
||||
|
||||
# HHMMSS.ffffff / HH:MM:SS.ffffff
|
||||
time_hmsu = [time(0, 0, 0, 0), time(4, 15, 3, 247993),
|
||||
time(14, 21, 59, 948730),
|
||||
time(23, 59, 59, 999999)]
|
||||
|
||||
time_hmsu_fmts = ['%H%M%S.%f', '%H:%M:%S.%f']
|
||||
|
||||
outputs.append(it.product(time_hmsu, time_hmsu_fmts))
|
||||
|
||||
outputs = list(map(list, outputs))
|
||||
|
||||
# Time zones
|
||||
ex_naive = list(it.chain.from_iterable(x[0:2] for x in outputs))
|
||||
o = it.product(ex_naive, TZOFFSETS) # ((time, fmt), (tzinfo, offsetstr))
|
||||
o = ((t.replace(tzinfo=tzi), fmt + off_str)
|
||||
for (t, fmt), (tzi, off_str) in o)
|
||||
|
||||
outputs.append(o)
|
||||
|
||||
return list(it.chain.from_iterable(outputs))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('time_val,time_fmt', __make_time_examples())
|
||||
@pytest.mark.parametrize('as_bytes', [True, False])
|
||||
def test_isotime(time_val, time_fmt, as_bytes):
|
||||
tstr = time_val.strftime(time_fmt)
|
||||
if isinstance(tstr, six.text_type) and as_bytes:
|
||||
tstr = tstr.encode('ascii')
|
||||
elif isinstance(tstr, bytes) and not as_bytes:
|
||||
tstr = tstr.decode('ascii')
|
||||
|
||||
iparser = isoparser()
|
||||
|
||||
assert iparser.parse_isotime(tstr) == time_val
|
||||
|
||||
|
||||
@pytest.mark.parametrize('isostr', [
|
||||
'24:00',
|
||||
'2400',
|
||||
'24:00:00',
|
||||
'240000',
|
||||
'24:00:00.000',
|
||||
'24:00:00,000',
|
||||
'24:00:00.000000',
|
||||
'24:00:00,000000',
|
||||
])
|
||||
def test_isotime_midnight(isostr):
|
||||
iparser = isoparser()
|
||||
assert iparser.parse_isotime(isostr) == time(0, 0, 0, 0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('isostr,exception', [
|
||||
('3', ValueError), # ISO string too short
|
||||
('14時30分15秒', ValueError), # Not ASCII
|
||||
('14_30_15', ValueError), # Invalid separators
|
||||
('1430:15', ValueError), # Inconsistent separator use
|
||||
('25', ValueError), # Invalid hours
|
||||
('25:15', ValueError), # Invalid hours
|
||||
('14:60', ValueError), # Invalid minutes
|
||||
('14:59:61', ValueError), # Invalid seconds
|
||||
('14:30:15.34468305:00', ValueError), # No sign in time zone
|
||||
('14:30:15+', ValueError), # Time zone too short
|
||||
('14:30:15+1234567', ValueError), # Time zone invalid
|
||||
('14:59:59+25:00', ValueError), # Invalid tz hours
|
||||
('14:59:59+12:62', ValueError), # Invalid tz minutes
|
||||
('14:59:30_344583', ValueError), # Invalid microsecond separator
|
||||
('24:01', ValueError), # 24 used for non-midnight time
|
||||
('24:00:01', ValueError), # 24 used for non-midnight time
|
||||
('24:00:00.001', ValueError), # 24 used for non-midnight time
|
||||
('24:00:00.000001', ValueError), # 24 used for non-midnight time
|
||||
])
|
||||
def test_isotime_raises(isostr, exception):
|
||||
iparser = isoparser()
|
||||
with pytest.raises(exception):
|
||||
iparser.parse_isotime(isostr)
|
||||
964
lib/dateutil/test/test_parser.py
Normal file
964
lib/dateutil/test/test_parser.py
Normal file
|
|
@ -0,0 +1,964 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
|
||||
import itertools
|
||||
from datetime import datetime, timedelta
|
||||
import unittest
|
||||
import sys
|
||||
|
||||
from dateutil import tz
|
||||
from dateutil.tz import tzoffset
|
||||
from dateutil.parser import parse, parserinfo
|
||||
from dateutil.parser import ParserError
|
||||
from dateutil.parser import UnknownTimezoneWarning
|
||||
|
||||
from ._common import TZEnvContext
|
||||
|
||||
from six import assertRaisesRegex, PY2
|
||||
from io import StringIO
|
||||
|
||||
import pytest
|
||||
|
||||
# Platform info
|
||||
IS_WIN = sys.platform.startswith('win')
|
||||
|
||||
PLATFORM_HAS_DASH_D = False
|
||||
try:
|
||||
if datetime.now().strftime('%-d'):
|
||||
PLATFORM_HAS_DASH_D = True
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
|
||||
@pytest.fixture(params=[True, False])
|
||||
def fuzzy(request):
|
||||
"""Fixture to pass fuzzy=True or fuzzy=False to parse"""
|
||||
return request.param
|
||||
|
||||
|
||||
# Parser test cases using no keyword arguments. Format: (parsable_text, expected_datetime, assertion_message)
|
||||
PARSER_TEST_CASES = [
|
||||
("Thu Sep 25 10:36:28 2003", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("Thu Sep 25 2003", datetime(2003, 9, 25), "date command format strip"),
|
||||
("2003-09-25T10:49:41", datetime(2003, 9, 25, 10, 49, 41), "iso format strip"),
|
||||
("2003-09-25T10:49", datetime(2003, 9, 25, 10, 49), "iso format strip"),
|
||||
("2003-09-25T10", datetime(2003, 9, 25, 10), "iso format strip"),
|
||||
("2003-09-25", datetime(2003, 9, 25), "iso format strip"),
|
||||
("20030925T104941", datetime(2003, 9, 25, 10, 49, 41), "iso stripped format strip"),
|
||||
("20030925T1049", datetime(2003, 9, 25, 10, 49, 0), "iso stripped format strip"),
|
||||
("20030925T10", datetime(2003, 9, 25, 10), "iso stripped format strip"),
|
||||
("20030925", datetime(2003, 9, 25), "iso stripped format strip"),
|
||||
("2003-09-25 10:49:41,502", datetime(2003, 9, 25, 10, 49, 41, 502000), "python logger format"),
|
||||
("199709020908", datetime(1997, 9, 2, 9, 8), "no separator"),
|
||||
("19970902090807", datetime(1997, 9, 2, 9, 8, 7), "no separator"),
|
||||
("09-25-2003", datetime(2003, 9, 25), "date with dash"),
|
||||
("25-09-2003", datetime(2003, 9, 25), "date with dash"),
|
||||
("10-09-2003", datetime(2003, 10, 9), "date with dash"),
|
||||
("10-09-03", datetime(2003, 10, 9), "date with dash"),
|
||||
("2003.09.25", datetime(2003, 9, 25), "date with dot"),
|
||||
("09.25.2003", datetime(2003, 9, 25), "date with dot"),
|
||||
("25.09.2003", datetime(2003, 9, 25), "date with dot"),
|
||||
("10.09.2003", datetime(2003, 10, 9), "date with dot"),
|
||||
("10.09.03", datetime(2003, 10, 9), "date with dot"),
|
||||
("2003/09/25", datetime(2003, 9, 25), "date with slash"),
|
||||
("09/25/2003", datetime(2003, 9, 25), "date with slash"),
|
||||
("25/09/2003", datetime(2003, 9, 25), "date with slash"),
|
||||
("10/09/2003", datetime(2003, 10, 9), "date with slash"),
|
||||
("10/09/03", datetime(2003, 10, 9), "date with slash"),
|
||||
("2003 09 25", datetime(2003, 9, 25), "date with space"),
|
||||
("09 25 2003", datetime(2003, 9, 25), "date with space"),
|
||||
("25 09 2003", datetime(2003, 9, 25), "date with space"),
|
||||
("10 09 2003", datetime(2003, 10, 9), "date with space"),
|
||||
("10 09 03", datetime(2003, 10, 9), "date with space"),
|
||||
("25 09 03", datetime(2003, 9, 25), "date with space"),
|
||||
("03 25 Sep", datetime(2003, 9, 25), "strangely ordered date"),
|
||||
("25 03 Sep", datetime(2025, 9, 3), "strangely ordered date"),
|
||||
(" July 4 , 1976 12:01:02 am ", datetime(1976, 7, 4, 0, 1, 2), "extra space"),
|
||||
("Wed, July 10, '96", datetime(1996, 7, 10, 0, 0), "random format"),
|
||||
("1996.July.10 AD 12:08 PM", datetime(1996, 7, 10, 12, 8), "random format"),
|
||||
("July 4, 1976", datetime(1976, 7, 4), "random format"),
|
||||
("7 4 1976", datetime(1976, 7, 4), "random format"),
|
||||
("4 jul 1976", datetime(1976, 7, 4), "random format"),
|
||||
("4 Jul 1976", datetime(1976, 7, 4), "'%-d %b %Y' format"),
|
||||
("7-4-76", datetime(1976, 7, 4), "random format"),
|
||||
("19760704", datetime(1976, 7, 4), "random format"),
|
||||
("0:01:02 on July 4, 1976", datetime(1976, 7, 4, 0, 1, 2), "random format"),
|
||||
("July 4, 1976 12:01:02 am", datetime(1976, 7, 4, 0, 1, 2), "random format"),
|
||||
("Mon Jan 2 04:24:27 1995", datetime(1995, 1, 2, 4, 24, 27), "random format"),
|
||||
("04.04.95 00:22", datetime(1995, 4, 4, 0, 22), "random format"),
|
||||
("Jan 1 1999 11:23:34.578", datetime(1999, 1, 1, 11, 23, 34, 578000), "random format"),
|
||||
("950404 122212", datetime(1995, 4, 4, 12, 22, 12), "random format"),
|
||||
("3rd of May 2001", datetime(2001, 5, 3), "random format"),
|
||||
("5th of March 2001", datetime(2001, 3, 5), "random format"),
|
||||
("1st of May 2003", datetime(2003, 5, 1), "random format"),
|
||||
('0099-01-01T00:00:00', datetime(99, 1, 1, 0, 0), "99 ad"),
|
||||
('0031-01-01T00:00:00', datetime(31, 1, 1, 0, 0), "31 ad"),
|
||||
("20080227T21:26:01.123456789", datetime(2008, 2, 27, 21, 26, 1, 123456), "high precision seconds"),
|
||||
('13NOV2017', datetime(2017, 11, 13), "dBY (See GH360)"),
|
||||
('0003-03-04', datetime(3, 3, 4), "pre 12 year same month (See GH PR #293)"),
|
||||
('December.0031.30', datetime(31, 12, 30), "BYd corner case (GH#687)"),
|
||||
|
||||
# Cases with legacy h/m/s format, candidates for deprecation (GH#886)
|
||||
("2016-12-21 04.2h", datetime(2016, 12, 21, 4, 12), "Fractional Hours"),
|
||||
]
|
||||
# Check that we don't have any duplicates
|
||||
assert len(set([x[0] for x in PARSER_TEST_CASES])) == len(PARSER_TEST_CASES)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("parsable_text,expected_datetime,assertion_message", PARSER_TEST_CASES)
|
||||
def test_parser(parsable_text, expected_datetime, assertion_message):
|
||||
assert parse(parsable_text) == expected_datetime, assertion_message
|
||||
|
||||
|
||||
# Parser test cases using datetime(2003, 9, 25) as a default.
|
||||
# Format: (parsable_text, expected_datetime, assertion_message)
|
||||
PARSER_DEFAULT_TEST_CASES = [
|
||||
("Thu Sep 25 10:36:28", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("Thu Sep 10:36:28", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("Thu 10:36:28", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("Sep 10:36:28", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("10:36:28", datetime(2003, 9, 25, 10, 36, 28), "date command format strip"),
|
||||
("10:36", datetime(2003, 9, 25, 10, 36), "date command format strip"),
|
||||
("Sep 2003", datetime(2003, 9, 25), "date command format strip"),
|
||||
("Sep", datetime(2003, 9, 25), "date command format strip"),
|
||||
("2003", datetime(2003, 9, 25), "date command format strip"),
|
||||
("10h36m28.5s", datetime(2003, 9, 25, 10, 36, 28, 500000), "hour with letters"),
|
||||
("10h36m28s", datetime(2003, 9, 25, 10, 36, 28), "hour with letters strip"),
|
||||
("10h36m", datetime(2003, 9, 25, 10, 36), "hour with letters strip"),
|
||||
("10h", datetime(2003, 9, 25, 10), "hour with letters strip"),
|
||||
("10 h 36", datetime(2003, 9, 25, 10, 36), "hour with letters strip"),
|
||||
("10 h 36.5", datetime(2003, 9, 25, 10, 36, 30), "hour with letter strip"),
|
||||
("36 m 5", datetime(2003, 9, 25, 0, 36, 5), "hour with letters spaces"),
|
||||
("36 m 5 s", datetime(2003, 9, 25, 0, 36, 5), "minute with letters spaces"),
|
||||
("36 m 05", datetime(2003, 9, 25, 0, 36, 5), "minute with letters spaces"),
|
||||
("36 m 05 s", datetime(2003, 9, 25, 0, 36, 5), "minutes with letters spaces"),
|
||||
("10h am", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10h pm", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("10am", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10pm", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("10:00 am", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10:00 pm", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("10:00am", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10:00pm", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("10:00a.m", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10:00p.m", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("10:00a.m.", datetime(2003, 9, 25, 10), "hour am pm"),
|
||||
("10:00p.m.", datetime(2003, 9, 25, 22), "hour am pm"),
|
||||
("Wed", datetime(2003, 10, 1), "weekday alone"),
|
||||
("Wednesday", datetime(2003, 10, 1), "long weekday"),
|
||||
("October", datetime(2003, 10, 25), "long month"),
|
||||
("31-Dec-00", datetime(2000, 12, 31), "zero year"),
|
||||
("0:01:02", datetime(2003, 9, 25, 0, 1, 2), "random format"),
|
||||
("12h 01m02s am", datetime(2003, 9, 25, 0, 1, 2), "random format"),
|
||||
("12:08 PM", datetime(2003, 9, 25, 12, 8), "random format"),
|
||||
("01h02m03", datetime(2003, 9, 25, 1, 2, 3), "random format"),
|
||||
("01h02", datetime(2003, 9, 25, 1, 2), "random format"),
|
||||
("01h02s", datetime(2003, 9, 25, 1, 0, 2), "random format"),
|
||||
("01m02", datetime(2003, 9, 25, 0, 1, 2), "random format"),
|
||||
("01m02h", datetime(2003, 9, 25, 2, 1), "random format"),
|
||||
("2004 10 Apr 11h30m", datetime(2004, 4, 10, 11, 30), "random format")
|
||||
]
|
||||
# Check that we don't have any duplicates
|
||||
assert len(set([x[0] for x in PARSER_DEFAULT_TEST_CASES])) == len(PARSER_DEFAULT_TEST_CASES)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("parsable_text,expected_datetime,assertion_message", PARSER_DEFAULT_TEST_CASES)
|
||||
def test_parser_default(parsable_text, expected_datetime, assertion_message):
|
||||
assert parse(parsable_text, default=datetime(2003, 9, 25)) == expected_datetime, assertion_message
|
||||
|
||||
|
||||
@pytest.mark.parametrize('sep', ['-', '.', '/', ' '])
|
||||
def test_parse_dayfirst(sep):
|
||||
expected = datetime(2003, 9, 10)
|
||||
fmt = sep.join(['%d', '%m', '%Y'])
|
||||
dstr = expected.strftime(fmt)
|
||||
result = parse(dstr, dayfirst=True)
|
||||
assert result == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize('sep', ['-', '.', '/', ' '])
|
||||
def test_parse_yearfirst(sep):
|
||||
expected = datetime(2010, 9, 3)
|
||||
fmt = sep.join(['%Y', '%m', '%d'])
|
||||
dstr = expected.strftime(fmt)
|
||||
result = parse(dstr, yearfirst=True)
|
||||
assert result == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize('dstr,expected', [
|
||||
("Thu Sep 25 10:36:28 BRST 2003", datetime(2003, 9, 25, 10, 36, 28)),
|
||||
("1996.07.10 AD at 15:08:56 PDT", datetime(1996, 7, 10, 15, 8, 56)),
|
||||
("Tuesday, April 12, 1952 AD 3:30:42pm PST",
|
||||
datetime(1952, 4, 12, 15, 30, 42)),
|
||||
("November 5, 1994, 8:15:30 am EST", datetime(1994, 11, 5, 8, 15, 30)),
|
||||
("1994-11-05T08:15:30-05:00", datetime(1994, 11, 5, 8, 15, 30)),
|
||||
("1994-11-05T08:15:30Z", datetime(1994, 11, 5, 8, 15, 30)),
|
||||
("1976-07-04T00:01:02Z", datetime(1976, 7, 4, 0, 1, 2)),
|
||||
("1986-07-05T08:15:30z", datetime(1986, 7, 5, 8, 15, 30)),
|
||||
("Tue Apr 4 00:22:12 PDT 1995", datetime(1995, 4, 4, 0, 22, 12)),
|
||||
])
|
||||
def test_parse_ignoretz(dstr, expected):
|
||||
result = parse(dstr, ignoretz=True)
|
||||
assert result == expected
|
||||
|
||||
|
||||
_brsttz = tzoffset("BRST", -10800)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('dstr,expected', [
|
||||
("20030925T104941-0300",
|
||||
datetime(2003, 9, 25, 10, 49, 41, tzinfo=_brsttz)),
|
||||
("Thu, 25 Sep 2003 10:49:41 -0300",
|
||||
datetime(2003, 9, 25, 10, 49, 41, tzinfo=_brsttz)),
|
||||
("2003-09-25T10:49:41.5-03:00",
|
||||
datetime(2003, 9, 25, 10, 49, 41, 500000, tzinfo=_brsttz)),
|
||||
("2003-09-25T10:49:41-03:00",
|
||||
datetime(2003, 9, 25, 10, 49, 41, tzinfo=_brsttz)),
|
||||
("20030925T104941.5-0300",
|
||||
datetime(2003, 9, 25, 10, 49, 41, 500000, tzinfo=_brsttz)),
|
||||
])
|
||||
def test_parse_with_tzoffset(dstr, expected):
|
||||
# In these cases, we are _not_ passing a tzinfos arg
|
||||
result = parse(dstr)
|
||||
assert result == expected
|
||||
|
||||
|
||||
class TestFormat(object):
|
||||
|
||||
def test_ybd(self):
|
||||
# If we have a 4-digit year, a non-numeric month (abbreviated or not),
|
||||
# and a day (1 or 2 digits), then there is no ambiguity as to which
|
||||
# token is a year/month/day. This holds regardless of what order the
|
||||
# terms are in and for each of the separators below.
|
||||
|
||||
seps = ['-', ' ', '/', '.']
|
||||
|
||||
year_tokens = ['%Y']
|
||||
month_tokens = ['%b', '%B']
|
||||
day_tokens = ['%d']
|
||||
if PLATFORM_HAS_DASH_D:
|
||||
day_tokens.append('%-d')
|
||||
|
||||
prods = itertools.product(year_tokens, month_tokens, day_tokens)
|
||||
perms = [y for x in prods for y in itertools.permutations(x)]
|
||||
unambig_fmts = [sep.join(perm) for sep in seps for perm in perms]
|
||||
|
||||
actual = datetime(2003, 9, 25)
|
||||
|
||||
for fmt in unambig_fmts:
|
||||
dstr = actual.strftime(fmt)
|
||||
res = parse(dstr)
|
||||
assert res == actual
|
||||
|
||||
# TODO: some redundancy with PARSER_TEST_CASES cases
|
||||
@pytest.mark.parametrize("fmt,dstr", [
|
||||
("%a %b %d %Y", "Thu Sep 25 2003"),
|
||||
("%b %d %Y", "Sep 25 2003"),
|
||||
("%Y-%m-%d", "2003-09-25"),
|
||||
("%Y%m%d", "20030925"),
|
||||
("%Y-%b-%d", "2003-Sep-25"),
|
||||
("%d-%b-%Y", "25-Sep-2003"),
|
||||
("%b-%d-%Y", "Sep-25-2003"),
|
||||
("%m-%d-%Y", "09-25-2003"),
|
||||
("%d-%m-%Y", "25-09-2003"),
|
||||
("%Y.%m.%d", "2003.09.25"),
|
||||
("%Y.%b.%d", "2003.Sep.25"),
|
||||
("%d.%b.%Y", "25.Sep.2003"),
|
||||
("%b.%d.%Y", "Sep.25.2003"),
|
||||
("%m.%d.%Y", "09.25.2003"),
|
||||
("%d.%m.%Y", "25.09.2003"),
|
||||
("%Y/%m/%d", "2003/09/25"),
|
||||
("%Y/%b/%d", "2003/Sep/25"),
|
||||
("%d/%b/%Y", "25/Sep/2003"),
|
||||
("%b/%d/%Y", "Sep/25/2003"),
|
||||
("%m/%d/%Y", "09/25/2003"),
|
||||
("%d/%m/%Y", "25/09/2003"),
|
||||
("%Y %m %d", "2003 09 25"),
|
||||
("%Y %b %d", "2003 Sep 25"),
|
||||
("%d %b %Y", "25 Sep 2003"),
|
||||
("%m %d %Y", "09 25 2003"),
|
||||
("%d %m %Y", "25 09 2003"),
|
||||
("%y %d %b", "03 25 Sep",),
|
||||
])
|
||||
def test_strftime_formats_2003Sep25(self, fmt, dstr):
|
||||
expected = datetime(2003, 9, 25)
|
||||
|
||||
# First check that the format strings behave as expected
|
||||
# (not strictly necessary, but nice to have)
|
||||
assert expected.strftime(fmt) == dstr
|
||||
|
||||
res = parse(dstr)
|
||||
assert res == expected
|
||||
|
||||
|
||||
class TestInputTypes(object):
|
||||
def test_empty_string_invalid(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse('')
|
||||
|
||||
def test_none_invalid(self):
|
||||
with pytest.raises(TypeError):
|
||||
parse(None)
|
||||
|
||||
def test_int_invalid(self):
|
||||
with pytest.raises(TypeError):
|
||||
parse(13)
|
||||
|
||||
def test_duck_typing(self):
|
||||
# We want to support arbitrary classes that implement the stream
|
||||
# interface.
|
||||
|
||||
class StringPassThrough(object):
|
||||
def __init__(self, stream):
|
||||
self.stream = stream
|
||||
|
||||
def read(self, *args, **kwargs):
|
||||
return self.stream.read(*args, **kwargs)
|
||||
|
||||
dstr = StringPassThrough(StringIO('2014 January 19'))
|
||||
|
||||
res = parse(dstr)
|
||||
expected = datetime(2014, 1, 19)
|
||||
assert res == expected
|
||||
|
||||
def test_parse_stream(self):
|
||||
dstr = StringIO('2014 January 19')
|
||||
|
||||
res = parse(dstr)
|
||||
expected = datetime(2014, 1, 19)
|
||||
assert res == expected
|
||||
|
||||
def test_parse_str(self):
|
||||
# Parser should be able to handle bytestring and unicode
|
||||
uni_str = '2014-05-01 08:00:00'
|
||||
bytes_str = uni_str.encode()
|
||||
|
||||
res = parse(bytes_str)
|
||||
expected = parse(uni_str)
|
||||
assert res == expected
|
||||
|
||||
def test_parse_bytes(self):
|
||||
res = parse(b'2014 January 19')
|
||||
expected = datetime(2014, 1, 19)
|
||||
assert res == expected
|
||||
|
||||
def test_parse_bytearray(self):
|
||||
# GH#417
|
||||
res = parse(bytearray(b'2014 January 19'))
|
||||
expected = datetime(2014, 1, 19)
|
||||
assert res == expected
|
||||
|
||||
|
||||
class TestTzinfoInputTypes(object):
|
||||
def assert_equal_same_tz(self, dt1, dt2):
|
||||
assert dt1 == dt2
|
||||
assert dt1.tzinfo is dt2.tzinfo
|
||||
|
||||
def test_tzinfo_dict_could_return_none(self):
|
||||
dstr = "2017-02-03 12:40 BRST"
|
||||
result = parse(dstr, tzinfos={"BRST": None})
|
||||
expected = datetime(2017, 2, 3, 12, 40)
|
||||
self.assert_equal_same_tz(result, expected)
|
||||
|
||||
def test_tzinfos_callable_could_return_none(self):
|
||||
dstr = "2017-02-03 12:40 BRST"
|
||||
result = parse(dstr, tzinfos=lambda *args: None)
|
||||
expected = datetime(2017, 2, 3, 12, 40)
|
||||
self.assert_equal_same_tz(result, expected)
|
||||
|
||||
def test_invalid_tzinfo_input(self):
|
||||
dstr = "2014 January 19 09:00 UTC"
|
||||
# Pass an absurd tzinfos object
|
||||
tzinfos = {"UTC": ValueError}
|
||||
with pytest.raises(TypeError):
|
||||
parse(dstr, tzinfos=tzinfos)
|
||||
|
||||
def test_valid_tzinfo_tzinfo_input(self):
|
||||
dstr = "2014 January 19 09:00 UTC"
|
||||
tzinfos = {"UTC": tz.UTC}
|
||||
expected = datetime(2014, 1, 19, 9, tzinfo=tz.UTC)
|
||||
res = parse(dstr, tzinfos=tzinfos)
|
||||
self.assert_equal_same_tz(res, expected)
|
||||
|
||||
def test_valid_tzinfo_unicode_input(self):
|
||||
dstr = "2014 January 19 09:00 UTC"
|
||||
tzinfos = {u"UTC": u"UTC+0"}
|
||||
expected = datetime(2014, 1, 19, 9, tzinfo=tz.tzstr("UTC+0"))
|
||||
res = parse(dstr, tzinfos=tzinfos)
|
||||
self.assert_equal_same_tz(res, expected)
|
||||
|
||||
def test_valid_tzinfo_callable_input(self):
|
||||
dstr = "2014 January 19 09:00 UTC"
|
||||
|
||||
def tzinfos(*args, **kwargs):
|
||||
return u"UTC+0"
|
||||
|
||||
expected = datetime(2014, 1, 19, 9, tzinfo=tz.tzstr("UTC+0"))
|
||||
res = parse(dstr, tzinfos=tzinfos)
|
||||
self.assert_equal_same_tz(res, expected)
|
||||
|
||||
def test_valid_tzinfo_int_input(self):
|
||||
dstr = "2014 January 19 09:00 UTC"
|
||||
tzinfos = {u"UTC": -28800}
|
||||
expected = datetime(2014, 1, 19, 9, tzinfo=tz.tzoffset(u"UTC", -28800))
|
||||
res = parse(dstr, tzinfos=tzinfos)
|
||||
self.assert_equal_same_tz(res, expected)
|
||||
|
||||
|
||||
class ParserTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setup_class(cls):
|
||||
cls.tzinfos = {"BRST": -10800}
|
||||
cls.brsttz = tzoffset("BRST", -10800)
|
||||
cls.default = datetime(2003, 9, 25)
|
||||
|
||||
# Parser should be able to handle bytestring and unicode
|
||||
cls.uni_str = '2014-05-01 08:00:00'
|
||||
cls.str_str = cls.uni_str.encode()
|
||||
|
||||
def testParserParseStr(self):
|
||||
from dateutil.parser import parser
|
||||
|
||||
assert parser().parse(self.str_str) == parser().parse(self.uni_str)
|
||||
|
||||
def testParseUnicodeWords(self):
|
||||
|
||||
class rus_parserinfo(parserinfo):
|
||||
MONTHS = [("янв", "Январь"),
|
||||
("фев", "Февраль"),
|
||||
("мар", "Март"),
|
||||
("апр", "Апрель"),
|
||||
("май", "Май"),
|
||||
("июн", "Июнь"),
|
||||
("июл", "Июль"),
|
||||
("авг", "Август"),
|
||||
("сен", "Сентябрь"),
|
||||
("окт", "Октябрь"),
|
||||
("ноя", "Ноябрь"),
|
||||
("дек", "Декабрь")]
|
||||
|
||||
expected = datetime(2015, 9, 10, 10, 20)
|
||||
res = parse('10 Сентябрь 2015 10:20', parserinfo=rus_parserinfo())
|
||||
assert res == expected
|
||||
|
||||
def testParseWithNulls(self):
|
||||
# This relies on the from __future__ import unicode_literals, because
|
||||
# explicitly specifying a unicode literal is a syntax error in Py 3.2
|
||||
# May want to switch to u'...' if we ever drop Python 3.2 support.
|
||||
pstring = '\x00\x00August 29, 1924'
|
||||
|
||||
assert parse(pstring) == datetime(1924, 8, 29)
|
||||
|
||||
def testDateCommandFormat(self):
|
||||
self.assertEqual(parse("Thu Sep 25 10:36:28 BRST 2003",
|
||||
tzinfos=self.tzinfos),
|
||||
datetime(2003, 9, 25, 10, 36, 28,
|
||||
tzinfo=self.brsttz))
|
||||
|
||||
def testDateCommandFormatReversed(self):
|
||||
self.assertEqual(parse("2003 10:36:28 BRST 25 Sep Thu",
|
||||
tzinfos=self.tzinfos),
|
||||
datetime(2003, 9, 25, 10, 36, 28,
|
||||
tzinfo=self.brsttz))
|
||||
|
||||
def testDateCommandFormatWithLong(self):
|
||||
if PY2:
|
||||
self.assertEqual(parse("Thu Sep 25 10:36:28 BRST 2003",
|
||||
tzinfos={"BRST": long(-10800)}),
|
||||
datetime(2003, 9, 25, 10, 36, 28,
|
||||
tzinfo=self.brsttz))
|
||||
|
||||
def testISOFormatStrip2(self):
|
||||
self.assertEqual(parse("2003-09-25T10:49:41+03:00"),
|
||||
datetime(2003, 9, 25, 10, 49, 41,
|
||||
tzinfo=tzoffset(None, 10800)))
|
||||
|
||||
def testISOStrippedFormatStrip2(self):
|
||||
self.assertEqual(parse("20030925T104941+0300"),
|
||||
datetime(2003, 9, 25, 10, 49, 41,
|
||||
tzinfo=tzoffset(None, 10800)))
|
||||
|
||||
def testAMPMNoHour(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse("AM")
|
||||
|
||||
with pytest.raises(ParserError):
|
||||
parse("Jan 20, 2015 PM")
|
||||
|
||||
def testAMPMRange(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse("13:44 AM")
|
||||
|
||||
with pytest.raises(ParserError):
|
||||
parse("January 25, 1921 23:13 PM")
|
||||
|
||||
def testPertain(self):
|
||||
self.assertEqual(parse("Sep 03", default=self.default),
|
||||
datetime(2003, 9, 3))
|
||||
self.assertEqual(parse("Sep of 03", default=self.default),
|
||||
datetime(2003, 9, 25))
|
||||
|
||||
def testFuzzy(self):
|
||||
s = "Today is 25 of September of 2003, exactly " \
|
||||
"at 10:49:41 with timezone -03:00."
|
||||
self.assertEqual(parse(s, fuzzy=True),
|
||||
datetime(2003, 9, 25, 10, 49, 41,
|
||||
tzinfo=self.brsttz))
|
||||
|
||||
def testFuzzyWithTokens(self):
|
||||
s1 = "Today is 25 of September of 2003, exactly " \
|
||||
"at 10:49:41 with timezone -03:00."
|
||||
self.assertEqual(parse(s1, fuzzy_with_tokens=True),
|
||||
(datetime(2003, 9, 25, 10, 49, 41,
|
||||
tzinfo=self.brsttz),
|
||||
('Today is ', 'of ', ', exactly at ',
|
||||
' with timezone ', '.')))
|
||||
|
||||
s2 = "http://biz.yahoo.com/ipo/p/600221.html"
|
||||
self.assertEqual(parse(s2, fuzzy_with_tokens=True),
|
||||
(datetime(2060, 2, 21, 0, 0, 0),
|
||||
('http://biz.yahoo.com/ipo/p/', '.html')))
|
||||
|
||||
def testFuzzyAMPMProblem(self):
|
||||
# Sometimes fuzzy parsing results in AM/PM flag being set without
|
||||
# hours - if it's fuzzy it should ignore that.
|
||||
s1 = "I have a meeting on March 1, 1974."
|
||||
s2 = "On June 8th, 2020, I am going to be the first man on Mars"
|
||||
|
||||
# Also don't want any erroneous AM or PMs changing the parsed time
|
||||
s3 = "Meet me at the AM/PM on Sunset at 3:00 AM on December 3rd, 2003"
|
||||
s4 = "Meet me at 3:00AM on December 3rd, 2003 at the AM/PM on Sunset"
|
||||
|
||||
self.assertEqual(parse(s1, fuzzy=True), datetime(1974, 3, 1))
|
||||
self.assertEqual(parse(s2, fuzzy=True), datetime(2020, 6, 8))
|
||||
self.assertEqual(parse(s3, fuzzy=True), datetime(2003, 12, 3, 3))
|
||||
self.assertEqual(parse(s4, fuzzy=True), datetime(2003, 12, 3, 3))
|
||||
|
||||
def testFuzzyIgnoreAMPM(self):
|
||||
s1 = "Jan 29, 1945 14:45 AM I going to see you there?"
|
||||
with pytest.warns(UnknownTimezoneWarning):
|
||||
res = parse(s1, fuzzy=True)
|
||||
self.assertEqual(res, datetime(1945, 1, 29, 14, 45))
|
||||
|
||||
def testRandomFormat24(self):
|
||||
self.assertEqual(parse("0:00 PM, PST", default=self.default,
|
||||
ignoretz=True),
|
||||
datetime(2003, 9, 25, 12, 0))
|
||||
|
||||
def testRandomFormat26(self):
|
||||
with pytest.warns(UnknownTimezoneWarning):
|
||||
res = parse("5:50 A.M. on June 13, 1990")
|
||||
|
||||
self.assertEqual(res, datetime(1990, 6, 13, 5, 50))
|
||||
|
||||
def testUnspecifiedDayFallback(self):
|
||||
# Test that for an unspecified day, the fallback behavior is correct.
|
||||
self.assertEqual(parse("April 2009", default=datetime(2010, 1, 31)),
|
||||
datetime(2009, 4, 30))
|
||||
|
||||
def testUnspecifiedDayFallbackFebNoLeapYear(self):
|
||||
self.assertEqual(parse("Feb 2007", default=datetime(2010, 1, 31)),
|
||||
datetime(2007, 2, 28))
|
||||
|
||||
def testUnspecifiedDayFallbackFebLeapYear(self):
|
||||
self.assertEqual(parse("Feb 2008", default=datetime(2010, 1, 31)),
|
||||
datetime(2008, 2, 29))
|
||||
|
||||
def testErrorType01(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse('shouldfail')
|
||||
|
||||
def testCorrectErrorOnFuzzyWithTokens(self):
|
||||
assertRaisesRegex(self, ParserError, 'Unknown string format',
|
||||
parse, '04/04/32/423', fuzzy_with_tokens=True)
|
||||
assertRaisesRegex(self, ParserError, 'Unknown string format',
|
||||
parse, '04/04/04 +32423', fuzzy_with_tokens=True)
|
||||
assertRaisesRegex(self, ParserError, 'Unknown string format',
|
||||
parse, '04/04/0d4', fuzzy_with_tokens=True)
|
||||
|
||||
def testIncreasingCTime(self):
|
||||
# This test will check 200 different years, every month, every day,
|
||||
# every hour, every minute, every second, and every weekday, using
|
||||
# a delta of more or less 1 year, 1 month, 1 day, 1 minute and
|
||||
# 1 second.
|
||||
delta = timedelta(days=365+31+1, seconds=1+60+60*60)
|
||||
dt = datetime(1900, 1, 1, 0, 0, 0, 0)
|
||||
for i in range(200):
|
||||
assert parse(dt.ctime()) == dt
|
||||
dt += delta
|
||||
|
||||
def testIncreasingISOFormat(self):
|
||||
delta = timedelta(days=365+31+1, seconds=1+60+60*60)
|
||||
dt = datetime(1900, 1, 1, 0, 0, 0, 0)
|
||||
for i in range(200):
|
||||
assert parse(dt.isoformat()) == dt
|
||||
dt += delta
|
||||
|
||||
def testMicrosecondsPrecisionError(self):
|
||||
# Skip found out that sad precision problem. :-(
|
||||
dt1 = parse("00:11:25.01")
|
||||
dt2 = parse("00:12:10.01")
|
||||
assert dt1.microsecond == 10000
|
||||
assert dt2.microsecond == 10000
|
||||
|
||||
def testMicrosecondPrecisionErrorReturns(self):
|
||||
# One more precision issue, discovered by Eric Brown. This should
|
||||
# be the last one, as we're no longer using floating points.
|
||||
for ms in [100001, 100000, 99999, 99998,
|
||||
10001, 10000, 9999, 9998,
|
||||
1001, 1000, 999, 998,
|
||||
101, 100, 99, 98]:
|
||||
dt = datetime(2008, 2, 27, 21, 26, 1, ms)
|
||||
assert parse(dt.isoformat()) == dt
|
||||
|
||||
def testCustomParserInfo(self):
|
||||
# Custom parser info wasn't working, as Michael Elsdörfer discovered.
|
||||
from dateutil.parser import parserinfo, parser
|
||||
|
||||
class myparserinfo(parserinfo):
|
||||
MONTHS = parserinfo.MONTHS[:]
|
||||
MONTHS[0] = ("Foo", "Foo")
|
||||
myparser = parser(myparserinfo())
|
||||
dt = myparser.parse("01/Foo/2007")
|
||||
assert dt == datetime(2007, 1, 1)
|
||||
|
||||
def testCustomParserShortDaynames(self):
|
||||
# Horacio Hoyos discovered that day names shorter than 3 characters,
|
||||
# for example two letter German day name abbreviations, don't work:
|
||||
# https://github.com/dateutil/dateutil/issues/343
|
||||
from dateutil.parser import parserinfo, parser
|
||||
|
||||
class GermanParserInfo(parserinfo):
|
||||
WEEKDAYS = [("Mo", "Montag"),
|
||||
("Di", "Dienstag"),
|
||||
("Mi", "Mittwoch"),
|
||||
("Do", "Donnerstag"),
|
||||
("Fr", "Freitag"),
|
||||
("Sa", "Samstag"),
|
||||
("So", "Sonntag")]
|
||||
|
||||
myparser = parser(GermanParserInfo())
|
||||
dt = myparser.parse("Sa 21. Jan 2017")
|
||||
self.assertEqual(dt, datetime(2017, 1, 21))
|
||||
|
||||
def testNoYearFirstNoDayFirst(self):
|
||||
dtstr = '090107'
|
||||
|
||||
# Should be MMDDYY
|
||||
self.assertEqual(parse(dtstr),
|
||||
datetime(2007, 9, 1))
|
||||
|
||||
self.assertEqual(parse(dtstr, yearfirst=False, dayfirst=False),
|
||||
datetime(2007, 9, 1))
|
||||
|
||||
def testYearFirst(self):
|
||||
dtstr = '090107'
|
||||
|
||||
# Should be MMDDYY
|
||||
self.assertEqual(parse(dtstr, yearfirst=True),
|
||||
datetime(2009, 1, 7))
|
||||
|
||||
self.assertEqual(parse(dtstr, yearfirst=True, dayfirst=False),
|
||||
datetime(2009, 1, 7))
|
||||
|
||||
def testDayFirst(self):
|
||||
dtstr = '090107'
|
||||
|
||||
# Should be DDMMYY
|
||||
self.assertEqual(parse(dtstr, dayfirst=True),
|
||||
datetime(2007, 1, 9))
|
||||
|
||||
self.assertEqual(parse(dtstr, yearfirst=False, dayfirst=True),
|
||||
datetime(2007, 1, 9))
|
||||
|
||||
def testDayFirstYearFirst(self):
|
||||
dtstr = '090107'
|
||||
# Should be YYDDMM
|
||||
self.assertEqual(parse(dtstr, yearfirst=True, dayfirst=True),
|
||||
datetime(2009, 7, 1))
|
||||
|
||||
def testUnambiguousYearFirst(self):
|
||||
dtstr = '2015 09 25'
|
||||
self.assertEqual(parse(dtstr, yearfirst=True),
|
||||
datetime(2015, 9, 25))
|
||||
|
||||
def testUnambiguousDayFirst(self):
|
||||
dtstr = '2015 09 25'
|
||||
self.assertEqual(parse(dtstr, dayfirst=True),
|
||||
datetime(2015, 9, 25))
|
||||
|
||||
def testUnambiguousDayFirstYearFirst(self):
|
||||
dtstr = '2015 09 25'
|
||||
self.assertEqual(parse(dtstr, dayfirst=True, yearfirst=True),
|
||||
datetime(2015, 9, 25))
|
||||
|
||||
def test_mstridx(self):
|
||||
# See GH408
|
||||
dtstr = '2015-15-May'
|
||||
self.assertEqual(parse(dtstr),
|
||||
datetime(2015, 5, 15))
|
||||
|
||||
def test_idx_check(self):
|
||||
dtstr = '2017-07-17 06:15:'
|
||||
# Pre-PR, the trailing colon will cause an IndexError at 824-825
|
||||
# when checking `i < len_l` and then accessing `l[i+1]`
|
||||
res = parse(dtstr, fuzzy=True)
|
||||
assert res == datetime(2017, 7, 17, 6, 15)
|
||||
|
||||
def test_hmBY(self):
|
||||
# See GH#483
|
||||
dtstr = '02:17NOV2017'
|
||||
res = parse(dtstr, default=self.default)
|
||||
assert res == datetime(2017, 11, self.default.day, 2, 17)
|
||||
|
||||
def test_validate_hour(self):
|
||||
# See GH353
|
||||
invalid = "201A-01-01T23:58:39.239769+03:00"
|
||||
with pytest.raises(ParserError):
|
||||
parse(invalid)
|
||||
|
||||
def test_era_trailing_year(self):
|
||||
dstr = 'AD2001'
|
||||
res = parse(dstr)
|
||||
assert res.year == 2001, res
|
||||
|
||||
def test_includes_timestr(self):
|
||||
timestr = "2020-13-97T44:61:83"
|
||||
|
||||
try:
|
||||
parse(timestr)
|
||||
except ParserError as e:
|
||||
assert e.args[1] == timestr
|
||||
else:
|
||||
pytest.fail("Failed to raise ParserError")
|
||||
|
||||
|
||||
class TestOutOfBounds(object):
|
||||
|
||||
def test_no_year_zero(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse("0000 Jun 20")
|
||||
|
||||
def test_out_of_bound_day(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse("Feb 30, 2007")
|
||||
|
||||
def test_illegal_month_error(self):
|
||||
with pytest.raises(ParserError):
|
||||
parse("0-100")
|
||||
|
||||
def test_day_sanity(self, fuzzy):
|
||||
dstr = "2014-15-25"
|
||||
with pytest.raises(ParserError):
|
||||
parse(dstr, fuzzy=fuzzy)
|
||||
|
||||
def test_minute_sanity(self, fuzzy):
|
||||
dstr = "2014-02-28 22:64"
|
||||
with pytest.raises(ParserError):
|
||||
parse(dstr, fuzzy=fuzzy)
|
||||
|
||||
def test_hour_sanity(self, fuzzy):
|
||||
dstr = "2014-02-28 25:16 PM"
|
||||
with pytest.raises(ParserError):
|
||||
parse(dstr, fuzzy=fuzzy)
|
||||
|
||||
def test_second_sanity(self, fuzzy):
|
||||
dstr = "2014-02-28 22:14:64"
|
||||
with pytest.raises(ParserError):
|
||||
parse(dstr, fuzzy=fuzzy)
|
||||
|
||||
|
||||
class TestParseUnimplementedCases(object):
|
||||
@pytest.mark.xfail
|
||||
def test_somewhat_ambiguous_string(self):
|
||||
# Ref: github issue #487
|
||||
# The parser is choosing the wrong part for hour
|
||||
# causing datetime to raise an exception.
|
||||
dtstr = '1237 PM BRST Mon Oct 30 2017'
|
||||
res = parse(dtstr, tzinfo=self.tzinfos)
|
||||
assert res == datetime(2017, 10, 30, 12, 37, tzinfo=self.tzinfos)
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_YmdH_M_S(self):
|
||||
# found in nasdaq's ftp data
|
||||
dstr = '1991041310:19:24'
|
||||
expected = datetime(1991, 4, 13, 10, 19, 24)
|
||||
res = parse(dstr)
|
||||
assert res == expected, (res, expected)
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_first_century(self):
|
||||
dstr = '0031 Nov 03'
|
||||
expected = datetime(31, 11, 3)
|
||||
res = parse(dstr)
|
||||
assert res == expected, res
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_era_trailing_year_with_dots(self):
|
||||
dstr = 'A.D.2001'
|
||||
res = parse(dstr)
|
||||
assert res.year == 2001, res
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_ad_nospace(self):
|
||||
expected = datetime(6, 5, 19)
|
||||
for dstr in [' 6AD May 19', ' 06AD May 19',
|
||||
' 006AD May 19', ' 0006AD May 19']:
|
||||
res = parse(dstr)
|
||||
assert res == expected, (dstr, res)
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_four_letter_day(self):
|
||||
dstr = 'Frid Dec 30, 2016'
|
||||
expected = datetime(2016, 12, 30)
|
||||
res = parse(dstr)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_non_date_number(self):
|
||||
dstr = '1,700'
|
||||
with pytest.raises(ParserError):
|
||||
parse(dstr)
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_on_era(self):
|
||||
# This could be classified as an "eras" test, but the relevant part
|
||||
# about this is the ` on `
|
||||
dstr = '2:15 PM on January 2nd 1973 A.D.'
|
||||
expected = datetime(1973, 1, 2, 14, 15)
|
||||
res = parse(dstr)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_extraneous_year(self):
|
||||
# This was found in the wild at insidertrading.org
|
||||
dstr = "2011 MARTIN CHILDREN'S IRREVOCABLE TRUST u/a/d NOVEMBER 7, 2012"
|
||||
res = parse(dstr, fuzzy_with_tokens=True)
|
||||
expected = datetime(2012, 11, 7)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_extraneous_year_tokens(self):
|
||||
# This was found in the wild at insidertrading.org
|
||||
# Unlike in the case above, identifying the first "2012" as the year
|
||||
# would not be a problem, but inferring that the latter 2012 is hhmm
|
||||
# is a problem.
|
||||
dstr = "2012 MARTIN CHILDREN'S IRREVOCABLE TRUST u/a/d NOVEMBER 7, 2012"
|
||||
expected = datetime(2012, 11, 7)
|
||||
(res, tokens) = parse(dstr, fuzzy_with_tokens=True)
|
||||
assert res == expected
|
||||
assert tokens == ("2012 MARTIN CHILDREN'S IRREVOCABLE TRUST u/a/d ",)
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_extraneous_year2(self):
|
||||
# This was found in the wild at insidertrading.org
|
||||
dstr = ("Berylson Amy Smith 1998 Grantor Retained Annuity Trust "
|
||||
"u/d/t November 2, 1998 f/b/o Jennifer L Berylson")
|
||||
res = parse(dstr, fuzzy_with_tokens=True)
|
||||
expected = datetime(1998, 11, 2)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_extraneous_year3(self):
|
||||
# This was found in the wild at insidertrading.org
|
||||
dstr = "SMITH R & WEISS D 94 CHILD TR FBO M W SMITH UDT 12/1/1994"
|
||||
res = parse(dstr, fuzzy_with_tokens=True)
|
||||
expected = datetime(1994, 12, 1)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_unambiguous_YYYYMM(self):
|
||||
# 171206 can be parsed as YYMMDD. However, 201712 cannot be parsed
|
||||
# as instance of YYMMDD and parser could fallback to YYYYMM format.
|
||||
dstr = "201712"
|
||||
res = parse(dstr)
|
||||
expected = datetime(2017, 12, 1)
|
||||
assert res == expected
|
||||
|
||||
@pytest.mark.xfail
|
||||
def test_extraneous_numerical_content(self):
|
||||
# ref: https://github.com/dateutil/dateutil/issues/1029
|
||||
# parser interprets price and percentage as parts of the date
|
||||
dstr = "£14.99 (25% off, until April 20)"
|
||||
res = parse(dstr, fuzzy=True, default=datetime(2000, 1, 1))
|
||||
expected = datetime(2000, 4, 20)
|
||||
assert res == expected
|
||||
|
||||
|
||||
@pytest.mark.skipif(IS_WIN, reason="Windows does not use TZ var")
|
||||
class TestTZVar(object):
|
||||
def test_parse_unambiguous_nonexistent_local(self):
|
||||
# When dates are specified "EST" even when they should be "EDT" in the
|
||||
# local time zone, we should still assign the local time zone
|
||||
with TZEnvContext('EST+5EDT,M3.2.0/2,M11.1.0/2'):
|
||||
dt_exp = datetime(2011, 8, 1, 12, 30, tzinfo=tz.tzlocal())
|
||||
dt = parse('2011-08-01T12:30 EST')
|
||||
|
||||
assert dt.tzname() == 'EDT'
|
||||
assert dt == dt_exp
|
||||
|
||||
def test_tzlocal_in_gmt(self):
|
||||
# GH #318
|
||||
with TZEnvContext('GMT0BST,M3.5.0,M10.5.0'):
|
||||
# This is an imaginary datetime in tz.tzlocal() but should still
|
||||
# parse using the GMT-as-alias-for-UTC rule
|
||||
dt = parse('2004-05-01T12:00 GMT')
|
||||
dt_exp = datetime(2004, 5, 1, 12, tzinfo=tz.UTC)
|
||||
|
||||
assert dt == dt_exp
|
||||
|
||||
def test_tzlocal_parse_fold(self):
|
||||
# One manifestion of GH #318
|
||||
with TZEnvContext('EST+5EDT,M3.2.0/2,M11.1.0/2'):
|
||||
dt_exp = datetime(2011, 11, 6, 1, 30, tzinfo=tz.tzlocal())
|
||||
dt_exp = tz.enfold(dt_exp, fold=1)
|
||||
dt = parse('2011-11-06T01:30 EST')
|
||||
|
||||
# Because this is ambiguous, until `tz.tzlocal() is tz.tzlocal()`
|
||||
# we'll just check the attributes we care about rather than
|
||||
# dt == dt_exp
|
||||
assert dt.tzname() == dt_exp.tzname()
|
||||
assert dt.replace(tzinfo=None) == dt_exp.replace(tzinfo=None)
|
||||
assert getattr(dt, 'fold') == getattr(dt_exp, 'fold')
|
||||
assert dt.astimezone(tz.UTC) == dt_exp.astimezone(tz.UTC)
|
||||
|
||||
|
||||
def test_parse_tzinfos_fold():
|
||||
NYC = tz.gettz('America/New_York')
|
||||
tzinfos = {'EST': NYC, 'EDT': NYC}
|
||||
|
||||
dt_exp = tz.enfold(datetime(2011, 11, 6, 1, 30, tzinfo=NYC), fold=1)
|
||||
dt = parse('2011-11-06T01:30 EST', tzinfos=tzinfos)
|
||||
|
||||
assert dt == dt_exp
|
||||
assert dt.tzinfo is dt_exp.tzinfo
|
||||
assert getattr(dt, 'fold') == getattr(dt_exp, 'fold')
|
||||
assert dt.astimezone(tz.UTC) == dt_exp.astimezone(tz.UTC)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('dtstr,dt', [
|
||||
('5.6h', datetime(2003, 9, 25, 5, 36)),
|
||||
('5.6m', datetime(2003, 9, 25, 0, 5, 36)),
|
||||
# '5.6s' never had a rounding problem, test added for completeness
|
||||
('5.6s', datetime(2003, 9, 25, 0, 0, 5, 600000))
|
||||
])
|
||||
def test_rounding_floatlike_strings(dtstr, dt):
|
||||
assert parse(dtstr, default=datetime(2003, 9, 25)) == dt
|
||||
|
||||
|
||||
@pytest.mark.parametrize('value', ['1: test', 'Nan'])
|
||||
def test_decimal_error(value):
|
||||
# GH 632, GH 662 - decimal.Decimal raises some non-ParserError exception
|
||||
# when constructed with an invalid value
|
||||
with pytest.raises(ParserError):
|
||||
parse(value)
|
||||
|
||||
def test_parsererror_repr():
|
||||
# GH 991 — the __repr__ was not properly indented and so was never defined.
|
||||
# This tests the current behavior of the ParserError __repr__, but the
|
||||
# precise format is not guaranteed to be stable and may change even in
|
||||
# minor versions. This test exists to avoid regressions.
|
||||
s = repr(ParserError("Problem with string: %s", "2019-01-01"))
|
||||
|
||||
assert s == "ParserError('Problem with string: %s', '2019-01-01')"
|
||||
706
lib/dateutil/test/test_relativedelta.py
Normal file
706
lib/dateutil/test/test_relativedelta.py
Normal file
|
|
@ -0,0 +1,706 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
from ._common import NotAValue
|
||||
|
||||
import calendar
|
||||
from datetime import datetime, date, timedelta
|
||||
import unittest
|
||||
|
||||
import pytest
|
||||
|
||||
from dateutil.relativedelta import relativedelta, MO, TU, WE, FR, SU
|
||||
|
||||
|
||||
class RelativeDeltaTest(unittest.TestCase):
|
||||
now = datetime(2003, 9, 17, 20, 54, 47, 282310)
|
||||
today = date(2003, 9, 17)
|
||||
|
||||
def testInheritance(self):
|
||||
# Ensure that relativedelta is inheritance-friendly.
|
||||
class rdChildClass(relativedelta):
|
||||
pass
|
||||
|
||||
ccRD = rdChildClass(years=1, months=1, days=1, leapdays=1, weeks=1,
|
||||
hours=1, minutes=1, seconds=1, microseconds=1)
|
||||
|
||||
rd = relativedelta(years=1, months=1, days=1, leapdays=1, weeks=1,
|
||||
hours=1, minutes=1, seconds=1, microseconds=1)
|
||||
|
||||
self.assertEqual(type(ccRD + rd), type(ccRD),
|
||||
msg='Addition does not inherit type.')
|
||||
|
||||
self.assertEqual(type(ccRD - rd), type(ccRD),
|
||||
msg='Subtraction does not inherit type.')
|
||||
|
||||
self.assertEqual(type(-ccRD), type(ccRD),
|
||||
msg='Negation does not inherit type.')
|
||||
|
||||
self.assertEqual(type(ccRD * 5.0), type(ccRD),
|
||||
msg='Multiplication does not inherit type.')
|
||||
|
||||
self.assertEqual(type(ccRD / 5.0), type(ccRD),
|
||||
msg='Division does not inherit type.')
|
||||
|
||||
def testMonthEndMonthBeginning(self):
|
||||
self.assertEqual(relativedelta(datetime(2003, 1, 31, 23, 59, 59),
|
||||
datetime(2003, 3, 1, 0, 0, 0)),
|
||||
relativedelta(months=-1, seconds=-1))
|
||||
|
||||
self.assertEqual(relativedelta(datetime(2003, 3, 1, 0, 0, 0),
|
||||
datetime(2003, 1, 31, 23, 59, 59)),
|
||||
relativedelta(months=1, seconds=1))
|
||||
|
||||
def testMonthEndMonthBeginningLeapYear(self):
|
||||
self.assertEqual(relativedelta(datetime(2012, 1, 31, 23, 59, 59),
|
||||
datetime(2012, 3, 1, 0, 0, 0)),
|
||||
relativedelta(months=-1, seconds=-1))
|
||||
|
||||
self.assertEqual(relativedelta(datetime(2003, 3, 1, 0, 0, 0),
|
||||
datetime(2003, 1, 31, 23, 59, 59)),
|
||||
relativedelta(months=1, seconds=1))
|
||||
|
||||
def testNextMonth(self):
|
||||
self.assertEqual(self.now+relativedelta(months=+1),
|
||||
datetime(2003, 10, 17, 20, 54, 47, 282310))
|
||||
|
||||
def testNextMonthPlusOneWeek(self):
|
||||
self.assertEqual(self.now+relativedelta(months=+1, weeks=+1),
|
||||
datetime(2003, 10, 24, 20, 54, 47, 282310))
|
||||
|
||||
def testNextMonthPlusOneWeek10am(self):
|
||||
self.assertEqual(self.today +
|
||||
relativedelta(months=+1, weeks=+1, hour=10),
|
||||
datetime(2003, 10, 24, 10, 0))
|
||||
|
||||
def testNextMonthPlusOneWeek10amDiff(self):
|
||||
self.assertEqual(relativedelta(datetime(2003, 10, 24, 10, 0),
|
||||
self.today),
|
||||
relativedelta(months=+1, days=+7, hours=+10))
|
||||
|
||||
def testOneMonthBeforeOneYear(self):
|
||||
self.assertEqual(self.now+relativedelta(years=+1, months=-1),
|
||||
datetime(2004, 8, 17, 20, 54, 47, 282310))
|
||||
|
||||
def testMonthsOfDiffNumOfDays(self):
|
||||
self.assertEqual(date(2003, 1, 27)+relativedelta(months=+1),
|
||||
date(2003, 2, 27))
|
||||
self.assertEqual(date(2003, 1, 31)+relativedelta(months=+1),
|
||||
date(2003, 2, 28))
|
||||
self.assertEqual(date(2003, 1, 31)+relativedelta(months=+2),
|
||||
date(2003, 3, 31))
|
||||
|
||||
def testMonthsOfDiffNumOfDaysWithYears(self):
|
||||
self.assertEqual(date(2000, 2, 28)+relativedelta(years=+1),
|
||||
date(2001, 2, 28))
|
||||
self.assertEqual(date(2000, 2, 29)+relativedelta(years=+1),
|
||||
date(2001, 2, 28))
|
||||
|
||||
self.assertEqual(date(1999, 2, 28)+relativedelta(years=+1),
|
||||
date(2000, 2, 28))
|
||||
self.assertEqual(date(1999, 3, 1)+relativedelta(years=+1),
|
||||
date(2000, 3, 1))
|
||||
self.assertEqual(date(1999, 3, 1)+relativedelta(years=+1),
|
||||
date(2000, 3, 1))
|
||||
|
||||
self.assertEqual(date(2001, 2, 28)+relativedelta(years=-1),
|
||||
date(2000, 2, 28))
|
||||
self.assertEqual(date(2001, 3, 1)+relativedelta(years=-1),
|
||||
date(2000, 3, 1))
|
||||
|
||||
def testNextFriday(self):
|
||||
self.assertEqual(self.today+relativedelta(weekday=FR),
|
||||
date(2003, 9, 19))
|
||||
|
||||
def testNextFridayInt(self):
|
||||
self.assertEqual(self.today+relativedelta(weekday=calendar.FRIDAY),
|
||||
date(2003, 9, 19))
|
||||
|
||||
def testLastFridayInThisMonth(self):
|
||||
self.assertEqual(self.today+relativedelta(day=31, weekday=FR(-1)),
|
||||
date(2003, 9, 26))
|
||||
|
||||
def testLastDayOfFebruary(self):
|
||||
self.assertEqual(date(2021, 2, 1) + relativedelta(day=31),
|
||||
date(2021, 2, 28))
|
||||
|
||||
def testLastDayOfFebruaryLeapYear(self):
|
||||
self.assertEqual(date(2020, 2, 1) + relativedelta(day=31),
|
||||
date(2020, 2, 29))
|
||||
|
||||
def testNextWednesdayIsToday(self):
|
||||
self.assertEqual(self.today+relativedelta(weekday=WE),
|
||||
date(2003, 9, 17))
|
||||
|
||||
def testNextWednesdayNotToday(self):
|
||||
self.assertEqual(self.today+relativedelta(days=+1, weekday=WE),
|
||||
date(2003, 9, 24))
|
||||
|
||||
def testAddMoreThan12Months(self):
|
||||
self.assertEqual(date(2003, 12, 1) + relativedelta(months=+13),
|
||||
date(2005, 1, 1))
|
||||
|
||||
def testAddNegativeMonths(self):
|
||||
self.assertEqual(date(2003, 1, 1) + relativedelta(months=-2),
|
||||
date(2002, 11, 1))
|
||||
|
||||
def test15thISOYearWeek(self):
|
||||
self.assertEqual(date(2003, 1, 1) +
|
||||
relativedelta(day=4, weeks=+14, weekday=MO(-1)),
|
||||
date(2003, 4, 7))
|
||||
|
||||
def testMillenniumAge(self):
|
||||
self.assertEqual(relativedelta(self.now, date(2001, 1, 1)),
|
||||
relativedelta(years=+2, months=+8, days=+16,
|
||||
hours=+20, minutes=+54, seconds=+47,
|
||||
microseconds=+282310))
|
||||
|
||||
def testJohnAge(self):
|
||||
self.assertEqual(relativedelta(self.now,
|
||||
datetime(1978, 4, 5, 12, 0)),
|
||||
relativedelta(years=+25, months=+5, days=+12,
|
||||
hours=+8, minutes=+54, seconds=+47,
|
||||
microseconds=+282310))
|
||||
|
||||
def testJohnAgeWithDate(self):
|
||||
self.assertEqual(relativedelta(self.today,
|
||||
datetime(1978, 4, 5, 12, 0)),
|
||||
relativedelta(years=+25, months=+5, days=+11,
|
||||
hours=+12))
|
||||
|
||||
def testYearDay(self):
|
||||
self.assertEqual(date(2003, 1, 1)+relativedelta(yearday=260),
|
||||
date(2003, 9, 17))
|
||||
self.assertEqual(date(2002, 1, 1)+relativedelta(yearday=260),
|
||||
date(2002, 9, 17))
|
||||
self.assertEqual(date(2000, 1, 1)+relativedelta(yearday=260),
|
||||
date(2000, 9, 16))
|
||||
self.assertEqual(self.today+relativedelta(yearday=261),
|
||||
date(2003, 9, 18))
|
||||
|
||||
def testYearDayBug(self):
|
||||
# Tests a problem reported by Adam Ryan.
|
||||
self.assertEqual(date(2010, 1, 1)+relativedelta(yearday=15),
|
||||
date(2010, 1, 15))
|
||||
|
||||
def testNonLeapYearDay(self):
|
||||
self.assertEqual(date(2003, 1, 1)+relativedelta(nlyearday=260),
|
||||
date(2003, 9, 17))
|
||||
self.assertEqual(date(2002, 1, 1)+relativedelta(nlyearday=260),
|
||||
date(2002, 9, 17))
|
||||
self.assertEqual(date(2000, 1, 1)+relativedelta(nlyearday=260),
|
||||
date(2000, 9, 17))
|
||||
self.assertEqual(self.today+relativedelta(yearday=261),
|
||||
date(2003, 9, 18))
|
||||
|
||||
def testAddition(self):
|
||||
self.assertEqual(relativedelta(days=10) +
|
||||
relativedelta(years=1, months=2, days=3, hours=4,
|
||||
minutes=5, microseconds=6),
|
||||
relativedelta(years=1, months=2, days=13, hours=4,
|
||||
minutes=5, microseconds=6))
|
||||
|
||||
def testAbsoluteAddition(self):
|
||||
self.assertEqual(relativedelta() + relativedelta(day=0, hour=0),
|
||||
relativedelta(day=0, hour=0))
|
||||
self.assertEqual(relativedelta(day=0, hour=0) + relativedelta(),
|
||||
relativedelta(day=0, hour=0))
|
||||
|
||||
def testAdditionToDatetime(self):
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(days=1),
|
||||
datetime(2000, 1, 2))
|
||||
|
||||
def testRightAdditionToDatetime(self):
|
||||
self.assertEqual(relativedelta(days=1) + datetime(2000, 1, 1),
|
||||
datetime(2000, 1, 2))
|
||||
|
||||
def testAdditionInvalidType(self):
|
||||
with self.assertRaises(TypeError):
|
||||
relativedelta(days=3) + 9
|
||||
|
||||
def testAdditionUnsupportedType(self):
|
||||
# For unsupported types that define their own comparators, etc.
|
||||
self.assertIs(relativedelta(days=1) + NotAValue, NotAValue)
|
||||
|
||||
def testAdditionFloatValue(self):
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(days=float(1)),
|
||||
datetime(2000, 1, 2))
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(months=float(1)),
|
||||
datetime(2000, 2, 1))
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(years=float(1)),
|
||||
datetime(2001, 1, 1))
|
||||
|
||||
def testAdditionFloatFractionals(self):
|
||||
self.assertEqual(datetime(2000, 1, 1, 0) +
|
||||
relativedelta(days=float(0.5)),
|
||||
datetime(2000, 1, 1, 12))
|
||||
self.assertEqual(datetime(2000, 1, 1, 0, 0) +
|
||||
relativedelta(hours=float(0.5)),
|
||||
datetime(2000, 1, 1, 0, 30))
|
||||
self.assertEqual(datetime(2000, 1, 1, 0, 0, 0) +
|
||||
relativedelta(minutes=float(0.5)),
|
||||
datetime(2000, 1, 1, 0, 0, 30))
|
||||
self.assertEqual(datetime(2000, 1, 1, 0, 0, 0, 0) +
|
||||
relativedelta(seconds=float(0.5)),
|
||||
datetime(2000, 1, 1, 0, 0, 0, 500000))
|
||||
self.assertEqual(datetime(2000, 1, 1, 0, 0, 0, 0) +
|
||||
relativedelta(microseconds=float(500000.25)),
|
||||
datetime(2000, 1, 1, 0, 0, 0, 500000))
|
||||
|
||||
def testSubtraction(self):
|
||||
self.assertEqual(relativedelta(days=10) -
|
||||
relativedelta(years=1, months=2, days=3, hours=4,
|
||||
minutes=5, microseconds=6),
|
||||
relativedelta(years=-1, months=-2, days=7, hours=-4,
|
||||
minutes=-5, microseconds=-6))
|
||||
|
||||
def testRightSubtractionFromDatetime(self):
|
||||
self.assertEqual(datetime(2000, 1, 2) - relativedelta(days=1),
|
||||
datetime(2000, 1, 1))
|
||||
|
||||
def testSubractionWithDatetime(self):
|
||||
self.assertRaises(TypeError, lambda x, y: x - y,
|
||||
(relativedelta(days=1), datetime(2000, 1, 1)))
|
||||
|
||||
def testSubtractionInvalidType(self):
|
||||
with self.assertRaises(TypeError):
|
||||
relativedelta(hours=12) - 14
|
||||
|
||||
def testSubtractionUnsupportedType(self):
|
||||
self.assertIs(relativedelta(days=1) + NotAValue, NotAValue)
|
||||
|
||||
def testMultiplication(self):
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(days=1) * 28,
|
||||
datetime(2000, 1, 29))
|
||||
self.assertEqual(datetime(2000, 1, 1) + 28 * relativedelta(days=1),
|
||||
datetime(2000, 1, 29))
|
||||
|
||||
def testMultiplicationUnsupportedType(self):
|
||||
self.assertIs(relativedelta(days=1) * NotAValue, NotAValue)
|
||||
|
||||
def testDivision(self):
|
||||
self.assertEqual(datetime(2000, 1, 1) + relativedelta(days=28) / 28,
|
||||
datetime(2000, 1, 2))
|
||||
|
||||
def testDivisionUnsupportedType(self):
|
||||
self.assertIs(relativedelta(days=1) / NotAValue, NotAValue)
|
||||
|
||||
def testBoolean(self):
|
||||
self.assertFalse(relativedelta(days=0))
|
||||
self.assertTrue(relativedelta(days=1))
|
||||
|
||||
def testAbsoluteValueNegative(self):
|
||||
rd_base = relativedelta(years=-1, months=-5, days=-2, hours=-3,
|
||||
minutes=-5, seconds=-2, microseconds=-12)
|
||||
rd_expected = relativedelta(years=1, months=5, days=2, hours=3,
|
||||
minutes=5, seconds=2, microseconds=12)
|
||||
self.assertEqual(abs(rd_base), rd_expected)
|
||||
|
||||
def testAbsoluteValuePositive(self):
|
||||
rd_base = relativedelta(years=1, months=5, days=2, hours=3,
|
||||
minutes=5, seconds=2, microseconds=12)
|
||||
rd_expected = rd_base
|
||||
|
||||
self.assertEqual(abs(rd_base), rd_expected)
|
||||
|
||||
def testComparison(self):
|
||||
d1 = relativedelta(years=1, months=1, days=1, leapdays=0, hours=1,
|
||||
minutes=1, seconds=1, microseconds=1)
|
||||
d2 = relativedelta(years=1, months=1, days=1, leapdays=0, hours=1,
|
||||
minutes=1, seconds=1, microseconds=1)
|
||||
d3 = relativedelta(years=1, months=1, days=1, leapdays=0, hours=1,
|
||||
minutes=1, seconds=1, microseconds=2)
|
||||
|
||||
self.assertEqual(d1, d2)
|
||||
self.assertNotEqual(d1, d3)
|
||||
|
||||
def testInequalityTypeMismatch(self):
|
||||
# Different type
|
||||
self.assertFalse(relativedelta(year=1) == 19)
|
||||
|
||||
def testInequalityUnsupportedType(self):
|
||||
self.assertIs(relativedelta(hours=3) == NotAValue, NotAValue)
|
||||
|
||||
def testInequalityWeekdays(self):
|
||||
# Different weekdays
|
||||
no_wday = relativedelta(year=1997, month=4)
|
||||
wday_mo_1 = relativedelta(year=1997, month=4, weekday=MO(+1))
|
||||
wday_mo_2 = relativedelta(year=1997, month=4, weekday=MO(+2))
|
||||
wday_tu = relativedelta(year=1997, month=4, weekday=TU)
|
||||
|
||||
self.assertTrue(wday_mo_1 == wday_mo_1)
|
||||
|
||||
self.assertFalse(no_wday == wday_mo_1)
|
||||
self.assertFalse(wday_mo_1 == no_wday)
|
||||
|
||||
self.assertFalse(wday_mo_1 == wday_mo_2)
|
||||
self.assertFalse(wday_mo_2 == wday_mo_1)
|
||||
|
||||
self.assertFalse(wday_mo_1 == wday_tu)
|
||||
self.assertFalse(wday_tu == wday_mo_1)
|
||||
|
||||
def testMonthOverflow(self):
|
||||
self.assertEqual(relativedelta(months=273),
|
||||
relativedelta(years=22, months=9))
|
||||
|
||||
def testWeeks(self):
|
||||
# Test that the weeks property is working properly.
|
||||
rd = relativedelta(years=4, months=2, weeks=8, days=6)
|
||||
self.assertEqual((rd.weeks, rd.days), (8, 8 * 7 + 6))
|
||||
|
||||
rd.weeks = 3
|
||||
self.assertEqual((rd.weeks, rd.days), (3, 3 * 7 + 6))
|
||||
|
||||
def testRelativeDeltaRepr(self):
|
||||
self.assertEqual(repr(relativedelta(years=1, months=-1, days=15)),
|
||||
'relativedelta(years=+1, months=-1, days=+15)')
|
||||
|
||||
self.assertEqual(repr(relativedelta(months=14, seconds=-25)),
|
||||
'relativedelta(years=+1, months=+2, seconds=-25)')
|
||||
|
||||
self.assertEqual(repr(relativedelta(month=3, hour=3, weekday=SU(3))),
|
||||
'relativedelta(month=3, weekday=SU(+3), hour=3)')
|
||||
|
||||
def testRelativeDeltaFractionalYear(self):
|
||||
with self.assertRaises(ValueError):
|
||||
relativedelta(years=1.5)
|
||||
|
||||
def testRelativeDeltaFractionalMonth(self):
|
||||
with self.assertRaises(ValueError):
|
||||
relativedelta(months=1.5)
|
||||
|
||||
def testRelativeDeltaInvalidDatetimeObject(self):
|
||||
with self.assertRaises(TypeError):
|
||||
relativedelta(dt1='2018-01-01', dt2='2018-01-02')
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
relativedelta(dt1=datetime(2018, 1, 1), dt2='2018-01-02')
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
relativedelta(dt1='2018-01-01', dt2=datetime(2018, 1, 2))
|
||||
|
||||
def testRelativeDeltaFractionalAbsolutes(self):
|
||||
# Fractional absolute values will soon be unsupported,
|
||||
# check for the deprecation warning.
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(year=2.86)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(month=1.29)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(day=0.44)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(hour=23.98)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(minute=45.21)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(second=13.2)
|
||||
|
||||
with pytest.warns(DeprecationWarning):
|
||||
relativedelta(microsecond=157221.93)
|
||||
|
||||
def testRelativeDeltaFractionalRepr(self):
|
||||
rd = relativedelta(years=3, months=-2, days=1.25)
|
||||
|
||||
self.assertEqual(repr(rd),
|
||||
'relativedelta(years=+3, months=-2, days=+1.25)')
|
||||
|
||||
rd = relativedelta(hours=0.5, seconds=9.22)
|
||||
self.assertEqual(repr(rd),
|
||||
'relativedelta(hours=+0.5, seconds=+9.22)')
|
||||
|
||||
def testRelativeDeltaFractionalWeeks(self):
|
||||
# Equivalent to days=8, hours=18
|
||||
rd = relativedelta(weeks=1.25)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd,
|
||||
datetime(2009, 9, 11, 18))
|
||||
|
||||
def testRelativeDeltaFractionalDays(self):
|
||||
rd1 = relativedelta(days=1.48)
|
||||
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd1,
|
||||
datetime(2009, 9, 4, 11, 31, 12))
|
||||
|
||||
rd2 = relativedelta(days=1.5)
|
||||
self.assertEqual(d1 + rd2,
|
||||
datetime(2009, 9, 4, 12, 0, 0))
|
||||
|
||||
def testRelativeDeltaFractionalHours(self):
|
||||
rd = relativedelta(days=1, hours=12.5)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd,
|
||||
datetime(2009, 9, 4, 12, 30, 0))
|
||||
|
||||
def testRelativeDeltaFractionalMinutes(self):
|
||||
rd = relativedelta(hours=1, minutes=30.5)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd,
|
||||
datetime(2009, 9, 3, 1, 30, 30))
|
||||
|
||||
def testRelativeDeltaFractionalSeconds(self):
|
||||
rd = relativedelta(hours=5, minutes=30, seconds=30.5)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd,
|
||||
datetime(2009, 9, 3, 5, 30, 30, 500000))
|
||||
|
||||
def testRelativeDeltaFractionalPositiveOverflow(self):
|
||||
# Equivalent to (days=1, hours=14)
|
||||
rd1 = relativedelta(days=1.5, hours=2)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd1,
|
||||
datetime(2009, 9, 4, 14, 0, 0))
|
||||
|
||||
# Equivalent to (days=1, hours=14, minutes=45)
|
||||
rd2 = relativedelta(days=1.5, hours=2.5, minutes=15)
|
||||
d1 = datetime(2009, 9, 3, 0, 0)
|
||||
self.assertEqual(d1 + rd2,
|
||||
datetime(2009, 9, 4, 14, 45))
|
||||
|
||||
# Carry back up - equivalent to (days=2, hours=2, minutes=0, seconds=1)
|
||||
rd3 = relativedelta(days=1.5, hours=13, minutes=59.5, seconds=31)
|
||||
self.assertEqual(d1 + rd3,
|
||||
datetime(2009, 9, 5, 2, 0, 1))
|
||||
|
||||
def testRelativeDeltaFractionalNegativeDays(self):
|
||||
# Equivalent to (days=-1, hours=-1)
|
||||
rd1 = relativedelta(days=-1.5, hours=11)
|
||||
d1 = datetime(2009, 9, 3, 12, 0)
|
||||
self.assertEqual(d1 + rd1,
|
||||
datetime(2009, 9, 2, 11, 0, 0))
|
||||
|
||||
# Equivalent to (days=-1, hours=-9)
|
||||
rd2 = relativedelta(days=-1.25, hours=-3)
|
||||
self.assertEqual(d1 + rd2,
|
||||
datetime(2009, 9, 2, 3))
|
||||
|
||||
def testRelativeDeltaNormalizeFractionalDays(self):
|
||||
# Equivalent to (days=2, hours=18)
|
||||
rd1 = relativedelta(days=2.75)
|
||||
|
||||
self.assertEqual(rd1.normalized(), relativedelta(days=2, hours=18))
|
||||
|
||||
# Equivalent to (days=1, hours=11, minutes=31, seconds=12)
|
||||
rd2 = relativedelta(days=1.48)
|
||||
|
||||
self.assertEqual(rd2.normalized(),
|
||||
relativedelta(days=1, hours=11, minutes=31, seconds=12))
|
||||
|
||||
def testRelativeDeltaNormalizeFractionalDays2(self):
|
||||
# Equivalent to (hours=1, minutes=30)
|
||||
rd1 = relativedelta(hours=1.5)
|
||||
|
||||
self.assertEqual(rd1.normalized(), relativedelta(hours=1, minutes=30))
|
||||
|
||||
# Equivalent to (hours=3, minutes=17, seconds=5, microseconds=100)
|
||||
rd2 = relativedelta(hours=3.28472225)
|
||||
|
||||
self.assertEqual(rd2.normalized(),
|
||||
relativedelta(hours=3, minutes=17, seconds=5, microseconds=100))
|
||||
|
||||
def testRelativeDeltaNormalizeFractionalMinutes(self):
|
||||
# Equivalent to (minutes=15, seconds=36)
|
||||
rd1 = relativedelta(minutes=15.6)
|
||||
|
||||
self.assertEqual(rd1.normalized(),
|
||||
relativedelta(minutes=15, seconds=36))
|
||||
|
||||
# Equivalent to (minutes=25, seconds=20, microseconds=25000)
|
||||
rd2 = relativedelta(minutes=25.33375)
|
||||
|
||||
self.assertEqual(rd2.normalized(),
|
||||
relativedelta(minutes=25, seconds=20, microseconds=25000))
|
||||
|
||||
def testRelativeDeltaNormalizeFractionalSeconds(self):
|
||||
# Equivalent to (seconds=45, microseconds=25000)
|
||||
rd1 = relativedelta(seconds=45.025)
|
||||
self.assertEqual(rd1.normalized(),
|
||||
relativedelta(seconds=45, microseconds=25000))
|
||||
|
||||
def testRelativeDeltaFractionalPositiveOverflow2(self):
|
||||
# Equivalent to (days=1, hours=14)
|
||||
rd1 = relativedelta(days=1.5, hours=2)
|
||||
self.assertEqual(rd1.normalized(),
|
||||
relativedelta(days=1, hours=14))
|
||||
|
||||
# Equivalent to (days=1, hours=14, minutes=45)
|
||||
rd2 = relativedelta(days=1.5, hours=2.5, minutes=15)
|
||||
self.assertEqual(rd2.normalized(),
|
||||
relativedelta(days=1, hours=14, minutes=45))
|
||||
|
||||
# Carry back up - equivalent to:
|
||||
# (days=2, hours=2, minutes=0, seconds=2, microseconds=3)
|
||||
rd3 = relativedelta(days=1.5, hours=13, minutes=59.50045,
|
||||
seconds=31.473, microseconds=500003)
|
||||
self.assertEqual(rd3.normalized(),
|
||||
relativedelta(days=2, hours=2, minutes=0,
|
||||
seconds=2, microseconds=3))
|
||||
|
||||
def testRelativeDeltaFractionalNegativeOverflow(self):
|
||||
# Equivalent to (days=-1)
|
||||
rd1 = relativedelta(days=-0.5, hours=-12)
|
||||
self.assertEqual(rd1.normalized(),
|
||||
relativedelta(days=-1))
|
||||
|
||||
# Equivalent to (days=-1)
|
||||
rd2 = relativedelta(days=-1.5, hours=12)
|
||||
self.assertEqual(rd2.normalized(),
|
||||
relativedelta(days=-1))
|
||||
|
||||
# Equivalent to (days=-1, hours=-14, minutes=-45)
|
||||
rd3 = relativedelta(days=-1.5, hours=-2.5, minutes=-15)
|
||||
self.assertEqual(rd3.normalized(),
|
||||
relativedelta(days=-1, hours=-14, minutes=-45))
|
||||
|
||||
# Equivalent to (days=-1, hours=-14, minutes=+15)
|
||||
rd4 = relativedelta(days=-1.5, hours=-2.5, minutes=45)
|
||||
self.assertEqual(rd4.normalized(),
|
||||
relativedelta(days=-1, hours=-14, minutes=+15))
|
||||
|
||||
# Carry back up - equivalent to:
|
||||
# (days=-2, hours=-2, minutes=0, seconds=-2, microseconds=-3)
|
||||
rd3 = relativedelta(days=-1.5, hours=-13, minutes=-59.50045,
|
||||
seconds=-31.473, microseconds=-500003)
|
||||
self.assertEqual(rd3.normalized(),
|
||||
relativedelta(days=-2, hours=-2, minutes=0,
|
||||
seconds=-2, microseconds=-3))
|
||||
|
||||
def testInvalidYearDay(self):
|
||||
with self.assertRaises(ValueError):
|
||||
relativedelta(yearday=367)
|
||||
|
||||
def testAddTimedeltaToUnpopulatedRelativedelta(self):
|
||||
td = timedelta(
|
||||
days=1,
|
||||
seconds=1,
|
||||
microseconds=1,
|
||||
milliseconds=1,
|
||||
minutes=1,
|
||||
hours=1,
|
||||
weeks=1
|
||||
)
|
||||
|
||||
expected = relativedelta(
|
||||
weeks=1,
|
||||
days=1,
|
||||
hours=1,
|
||||
minutes=1,
|
||||
seconds=1,
|
||||
microseconds=1001
|
||||
)
|
||||
|
||||
self.assertEqual(expected, relativedelta() + td)
|
||||
|
||||
def testAddTimedeltaToPopulatedRelativeDelta(self):
|
||||
td = timedelta(
|
||||
days=1,
|
||||
seconds=1,
|
||||
microseconds=1,
|
||||
milliseconds=1,
|
||||
minutes=1,
|
||||
hours=1,
|
||||
weeks=1
|
||||
)
|
||||
|
||||
rd = relativedelta(
|
||||
year=1,
|
||||
month=1,
|
||||
day=1,
|
||||
hour=1,
|
||||
minute=1,
|
||||
second=1,
|
||||
microsecond=1,
|
||||
years=1,
|
||||
months=1,
|
||||
days=1,
|
||||
weeks=1,
|
||||
hours=1,
|
||||
minutes=1,
|
||||
seconds=1,
|
||||
microseconds=1
|
||||
)
|
||||
|
||||
expected = relativedelta(
|
||||
year=1,
|
||||
month=1,
|
||||
day=1,
|
||||
hour=1,
|
||||
minute=1,
|
||||
second=1,
|
||||
microsecond=1,
|
||||
years=1,
|
||||
months=1,
|
||||
weeks=2,
|
||||
days=2,
|
||||
hours=2,
|
||||
minutes=2,
|
||||
seconds=2,
|
||||
microseconds=1002,
|
||||
)
|
||||
|
||||
self.assertEqual(expected, rd + td)
|
||||
|
||||
def testHashable(self):
|
||||
try:
|
||||
{relativedelta(minute=1): 'test'}
|
||||
except:
|
||||
self.fail("relativedelta() failed to hash!")
|
||||
|
||||
|
||||
class RelativeDeltaWeeksPropertyGetterTest(unittest.TestCase):
|
||||
"""Test the weeks property getter"""
|
||||
|
||||
def test_one_day(self):
|
||||
rd = relativedelta(days=1)
|
||||
self.assertEqual(rd.days, 1)
|
||||
self.assertEqual(rd.weeks, 0)
|
||||
|
||||
def test_minus_one_day(self):
|
||||
rd = relativedelta(days=-1)
|
||||
self.assertEqual(rd.days, -1)
|
||||
self.assertEqual(rd.weeks, 0)
|
||||
|
||||
def test_height_days(self):
|
||||
rd = relativedelta(days=8)
|
||||
self.assertEqual(rd.days, 8)
|
||||
self.assertEqual(rd.weeks, 1)
|
||||
|
||||
def test_minus_height_days(self):
|
||||
rd = relativedelta(days=-8)
|
||||
self.assertEqual(rd.days, -8)
|
||||
self.assertEqual(rd.weeks, -1)
|
||||
|
||||
|
||||
class RelativeDeltaWeeksPropertySetterTest(unittest.TestCase):
|
||||
"""Test the weeks setter which makes a "smart" update of the days attribute"""
|
||||
|
||||
def test_one_day_set_one_week(self):
|
||||
rd = relativedelta(days=1)
|
||||
rd.weeks = 1 # add 7 days
|
||||
self.assertEqual(rd.days, 8)
|
||||
self.assertEqual(rd.weeks, 1)
|
||||
|
||||
def test_minus_one_day_set_one_week(self):
|
||||
rd = relativedelta(days=-1)
|
||||
rd.weeks = 1 # add 7 days
|
||||
self.assertEqual(rd.days, 6)
|
||||
self.assertEqual(rd.weeks, 0)
|
||||
|
||||
def test_height_days_set_minus_one_week(self):
|
||||
rd = relativedelta(days=8)
|
||||
rd.weeks = -1 # change from 1 week, 1 day to -1 week, 1 day
|
||||
self.assertEqual(rd.days, -6)
|
||||
self.assertEqual(rd.weeks, 0)
|
||||
|
||||
def test_minus_height_days_set_minus_one_week(self):
|
||||
rd = relativedelta(days=-8)
|
||||
rd.weeks = -1 # does not change anything
|
||||
self.assertEqual(rd.days, -8)
|
||||
self.assertEqual(rd.weeks, -1)
|
||||
|
||||
|
||||
# vim:ts=4:sw=4:et
|
||||
4914
lib/dateutil/test/test_rrule.py
Normal file
4914
lib/dateutil/test/test_rrule.py
Normal file
File diff suppressed because it is too large
Load diff
2811
lib/dateutil/test/test_tz.py
Normal file
2811
lib/dateutil/test/test_tz.py
Normal file
File diff suppressed because it is too large
Load diff
52
lib/dateutil/test/test_utils.py
Normal file
52
lib/dateutil/test/test_utils.py
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
from __future__ import unicode_literals
|
||||
from datetime import timedelta, datetime
|
||||
|
||||
from dateutil import tz
|
||||
from dateutil import utils
|
||||
from dateutil.tz import UTC
|
||||
from dateutil.utils import within_delta
|
||||
|
||||
from freezegun import freeze_time
|
||||
|
||||
NYC = tz.gettz("America/New_York")
|
||||
|
||||
|
||||
@freeze_time(datetime(2014, 12, 15, 1, 21, 33, 4003))
|
||||
def test_utils_today():
|
||||
assert utils.today() == datetime(2014, 12, 15, 0, 0, 0)
|
||||
|
||||
|
||||
@freeze_time(datetime(2014, 12, 15, 12), tz_offset=5)
|
||||
def test_utils_today_tz_info():
|
||||
assert utils.today(NYC) == datetime(2014, 12, 15, 0, 0, 0, tzinfo=NYC)
|
||||
|
||||
|
||||
@freeze_time(datetime(2014, 12, 15, 23), tz_offset=5)
|
||||
def test_utils_today_tz_info_different_day():
|
||||
assert utils.today(UTC) == datetime(2014, 12, 16, 0, 0, 0, tzinfo=UTC)
|
||||
|
||||
|
||||
def test_utils_default_tz_info_naive():
|
||||
dt = datetime(2014, 9, 14, 9, 30)
|
||||
assert utils.default_tzinfo(dt, NYC).tzinfo is NYC
|
||||
|
||||
|
||||
def test_utils_default_tz_info_aware():
|
||||
dt = datetime(2014, 9, 14, 9, 30, tzinfo=UTC)
|
||||
assert utils.default_tzinfo(dt, NYC).tzinfo is UTC
|
||||
|
||||
|
||||
def test_utils_within_delta():
|
||||
d1 = datetime(2016, 1, 1, 12, 14, 1, 9)
|
||||
d2 = d1.replace(microsecond=15)
|
||||
|
||||
assert within_delta(d1, d2, timedelta(seconds=1))
|
||||
assert not within_delta(d1, d2, timedelta(microseconds=1))
|
||||
|
||||
|
||||
def test_utils_within_delta_with_negative_delta():
|
||||
d1 = datetime(2016, 1, 1)
|
||||
d2 = datetime(2015, 12, 31)
|
||||
|
||||
assert within_delta(d2, d1, timedelta(days=-1))
|
||||
Loading…
Add table
Add a link
Reference in a new issue