############################################################################## # # Copyright (c) 2003 Zope Foundation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## import math import os import platform import sys import time import unittest from datetime import date from datetime import datetime from datetime import timedelta from datetime import tzinfo import pytz from DateTime import DateTime from DateTime.DateTime import _findLocalTimeZoneName if sys.version_info > (3, ): # pragma: PY3 import pickle unicode = str PY3K = True else: # pragma: PY2 import cPickle as pickle PY3K = False try: __file__ except NameError: # pragma: no cover f = sys.argv[0] else: f = __file__ IS_PYPY = getattr(platform, 'python_implementation', lambda: None)() == 'PyPy' DATADIR = os.path.dirname(os.path.abspath(f)) del f ZERO = timedelta(0) class FixedOffset(tzinfo): """Fixed offset in minutes east from UTC.""" def __init__(self, offset, name): self.__offset = timedelta(minutes=offset) self.__name = name def utcoffset(self, dt): return self.__offset def tzname(self, dt): return self.__name def dst(self, dt): return ZERO class DateTimeTests(unittest.TestCase): def _compare(self, dt1, dt2): '''Compares the internal representation of dt1 with the representation in dt2. Allows sub-millisecond variations. Primarily for testing.''' self.assertEqual(round(dt1._t, 3), round(dt2._t, 3)) self.assertEqual(round(dt1._d, 9), round(dt2._d, 9)) self.assertEqual(round(dt1.time, 9), round(dt2.time, 9)) self.assertEqual(dt1.millis(), dt2.millis()) self.assertEqual(dt1._micros, dt2._micros) def testBug1203(self): # 01:59:60 occurred in old DateTime dt = DateTime(7200, 'GMT') self.assertTrue(str(dt).find('60') < 0, dt) def testDSTInEffect(self): # Checks GMT offset for a DST date in the US/Eastern time zone dt = DateTime(2000, 5, 9, 15, 0, 0, 'US/Eastern') self.assertEqual(dt.toZone('GMT').hour(), 19, (dt, dt.toZone('GMT'))) def testDSTNotInEffect(self): # Checks GMT offset for a non-DST date in the US/Eastern time zone dt = DateTime(2000, 11, 9, 15, 0, 0, 'US/Eastern') self.assertEqual(dt.toZone('GMT').hour(), 20, (dt, dt.toZone('GMT'))) def testAddPrecision(self): # Precision of serial additions dt = DateTime() calculated_dt = dt + 0.10 + 3.14 + 6.76 - 10 self.assertEqual(str(calculated_dt), str(dt), dt) # checks problem reported in # https://github.com/zopefoundation/DateTime/issues/41 dt = DateTime(2038, 10, 7, 8, 52, 44.959840, "UTC") calculated_dt = dt + 0.10 + 3.14 + 6.76 - 10 self.assertEqual(str(calculated_dt), str(dt), dt) # checks regression on Py 2.7 where asdatetime gave an error py_dt = dt.asdatetime() py_calculated_dt = calculated_dt.asdatetime() self.assertEqual(py_dt, py_calculated_dt) def testConsistentSecondMicroRounding(self): dt = DateTime(2038, 10, 7, 8, 52, 44.9598398, "UTC") self.assertEqual(int(dt.second() * 1000000), dt.micros() % 60000000) def testConstructor3(self): # Constructor from date/time string dt = DateTime() dt1s = '%d/%d/%d %d:%d:%f %s' % ( dt.year(), dt.month(), dt.day(), dt.hour(), dt.minute(), dt.second(), dt.timezone()) dt1 = DateTime(dt1s) # Compare representations as it's the # only way to compare the dates to the same accuracy self.assertEqual(repr(dt), repr(dt1)) def testConstructor4(self): # Constructor from time float dt = DateTime() dt1 = DateTime(float(dt)) self._compare(dt, dt1) def testConstructor5(self): # Constructor from time float and timezone dt = DateTime() dt1 = DateTime(float(dt), dt.timezone()) self.assertEqual(str(dt), str(dt1), (dt, dt1)) dt1 = DateTime(float(dt), unicode(dt.timezone())) self.assertEqual(str(dt), str(dt1), (dt, dt1)) def testConstructor6(self): # Constructor from year and julian date # This test must normalize the time zone, or it *will* break when # DST changes! dt1 = DateTime(2000, 5.500000578705) dt = DateTime('2000/1/5 12:00:00.050 pm %s' % dt1.localZone()) self._compare(dt, dt1) def testConstructor7(self): # Constructor from parts dt = DateTime() dt1 = DateTime( dt.year(), dt.month(), dt.day(), dt.hour(), dt.minute(), dt.second(), dt.timezone()) # Compare representations as it's the # only way to compare the dates to the same accuracy self.assertEqual(repr(dt), repr(dt1)) def testDayOfWeek(self): # Compare to the datetime.date value to make it locale independent expected = date(2000, 6, 16).strftime('%A') # strftime() used to always be passed a day of week of 0 dt = DateTime('2000/6/16') s = dt.strftime('%A') self.assertEqual(s, expected, (dt, s)) def testOldDate(self): # Fails when an 1800 date is displayed with negative signs dt = DateTime('1830/5/6 12:31:46.213 pm') dt1 = dt.toZone('GMT+6') self.assertTrue(str(dt1).find('-') < 0, (dt, dt1)) def testSubtraction(self): # Reconstruction of a DateTime from its parts, with subtraction # this also tests the accuracy of addition and reconstruction dt = DateTime() dt1 = dt - 3.141592653 dt2 = DateTime( dt.year(), dt.month(), dt.day(), dt.hour(), dt.minute(), dt.second()) dt3 = dt2 - 3.141592653 self.assertEqual(dt1, dt3, (dt, dt1, dt2, dt3)) def testTZ1add(self): # Time zone manipulation: add to a date dt = DateTime('1997/3/8 1:45am GMT-4') dt1 = DateTime('1997/3/9 1:45pm GMT+8') self.assertTrue((dt + 1.0).equalTo(dt1)) def testTZ1sub(self): # Time zone manipulation: subtract from a date dt = DateTime('1997/3/8 1:45am GMT-4') dt1 = DateTime('1997/3/9 1:45pm GMT+8') self.assertTrue((dt1 - 1.0).equalTo(dt)) def testTZ1diff(self): # Time zone manipulation: diff two dates dt = DateTime('1997/3/8 1:45am GMT-4') dt1 = DateTime('1997/3/9 1:45pm GMT+8') self.assertEqual(dt1 - dt, 1.0, (dt, dt1)) def test_compare_methods(self): # Compare two dates using several methods dt = DateTime('1997/1/1') dt1 = DateTime('1997/2/2') self.assertTrue(dt1.greaterThan(dt)) self.assertTrue(dt1.greaterThanEqualTo(dt)) self.assertTrue(dt.lessThan(dt1)) self.assertTrue(dt.lessThanEqualTo(dt1)) self.assertTrue(dt.notEqualTo(dt1)) self.assertFalse(dt.equalTo(dt1)) def test_compare_methods_none(self): # Compare a date to None dt = DateTime('1997/1/1') self.assertTrue(dt.greaterThan(None)) self.assertTrue(dt.greaterThanEqualTo(None)) self.assertFalse(dt.lessThan(None)) self.assertFalse(dt.lessThanEqualTo(None)) self.assertTrue(dt.notEqualTo(None)) self.assertFalse(dt.equalTo(None)) def test_pickle(self): dt = DateTime() data = pickle.dumps(dt, 1) new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def test_pickle_with_tz(self): dt = DateTime('2002/5/2 8:00am GMT+8') data = pickle.dumps(dt, 1) new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def test_pickle_with_numerical_tz(self): for dt_str in ('2007/01/02 12:34:56.789 +0300', '2007/01/02 12:34:56.789 +0430', '2007/01/02 12:34:56.789 -1234'): dt = DateTime(dt_str) data = pickle.dumps(dt, 1) new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def test_pickle_with_micros(self): dt = DateTime('2002/5/2 8:00:14.123 GMT+8') data = pickle.dumps(dt, 1) new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def test_pickle_old(self): dt = DateTime('2002/5/2 8:00am GMT+0') data = ( '(cDateTime.DateTime\nDateTime\nq\x01Noq\x02}q\x03(U\x05' '_amonq\x04U\x03Mayq\x05U\x05_adayq\x06U\x03Thuq\x07U\x05_pmonq' '\x08h\x05U\x05_hourq\tK\x08U\x05_fmonq\nh\x05U\x05_pdayq\x0bU' '\x04Thu.q\x0cU\x05_fdayq\rU\x08Thursdayq\x0eU\x03_pmq\x0fU\x02amq' '\x10U\x02_tq\x11GA\xcehy\x00\x00\x00\x00U\x07_minuteq\x12K\x00U' '\x07_microsq\x13L1020326400000000L\nU\x02_dq\x14G@\xe2\x12j\xaa' '\xaa\xaa\xabU\x07_secondq\x15G\x00\x00\x00\x00\x00\x00\x00\x00U' '\x03_tzq\x16U\x05GMT+0q\x17U\x06_monthq\x18K\x05U' '\x0f_timezone_naiveq\x19I00\nU\x04_dayq\x1aK\x02U\x05_yearq' '\x1bM\xd2\x07U\x08_nearsecq\x1cG\x00\x00\x00\x00\x00\x00\x00' '\x00U\x07_pmhourq\x1dK\x08U\n_dayoffsetq\x1eK\x04U\x04timeq' '\x1fG?\xd5UUUV\x00\x00ub.') if PY3K: data = data.encode('latin-1') new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def test_pickle_old_without_micros(self): dt = DateTime('2002/5/2 8:00am GMT+0') data = ( '(cDateTime.DateTime\nDateTime\nq\x01Noq\x02}q\x03(U\x05' '_amonq\x04U\x03Mayq\x05U\x05_adayq\x06U\x03Thuq\x07U\x05_pmonq' '\x08h\x05U\x05_hourq\tK\x08U\x05_fmonq\nh\x05U\x05_pdayq\x0bU' '\x04Thu.q\x0cU\x05_fdayq\rU\x08Thursdayq\x0eU\x03_pmq\x0fU' '\x02amq\x10U\x02_tq\x11GA\xcehy\x00\x00\x00\x00U\x07_minuteq' '\x12K\x00U\x02_dq\x13G@\xe2\x12j\xaa\xaa\xaa\xabU\x07_secondq' '\x14G\x00\x00\x00\x00\x00\x00\x00\x00U\x03_tzq\x15U\x05GMT+0q' '\x16U\x06_monthq\x17K\x05U\x0f_timezone_naiveq\x18I00\nU' '\x04_dayq\x19K\x02U\x05_yearq\x1aM\xd2\x07U\x08_nearsecq' '\x1bG\x00\x00\x00\x00\x00\x00\x00\x00U\x07_pmhourq\x1cK\x08U' '\n_dayoffsetq\x1dK\x04U\x04timeq\x1eG?\xd5UUUV\x00\x00ub.') if PY3K: data = data.encode('latin-1') new = pickle.loads(data) for key in DateTime.__slots__: self.assertEqual(getattr(dt, key), getattr(new, key)) def testTZ2(self): # Time zone manipulation test 2 dt = DateTime() dt1 = dt.toZone('GMT') s = dt.second() s1 = dt1.second() self.assertEqual(s, s1, (dt, dt1, s, s1)) def testTZDiffDaylight(self): # Diff dates across daylight savings dates dt = DateTime('2000/6/8 1:45am US/Eastern') dt1 = DateTime('2000/12/8 12:45am US/Eastern') self.assertEqual(dt1 - dt, 183, (dt, dt1, dt1 - dt)) def testY10KDate(self): # Comparison of a Y10K date and a Y2K date dt = DateTime('10213/09/21') dt1 = DateTime(2000, 1, 1) dsec = (dt.millis() - dt1.millis()) / 1000.0 ddays = math.floor((dsec / 86400.0) + 0.5) self.assertEqual(ddays, 3000000, ddays) def test_tzoffset(self): # Test time-zone given as an offset # GMT dt = DateTime('Tue, 10 Sep 2001 09:41:03 GMT') self.assertEqual(dt.tzoffset(), 0) # Timezone by name, a timezone that hasn't got daylightsaving. dt = DateTime('Tue, 2 Mar 2001 09:41:03 GMT+3') self.assertEqual(dt.tzoffset(), 10800) # Timezone by name, has daylightsaving but is not in effect. dt = DateTime('Tue, 21 Jan 2001 09:41:03 PST') self.assertEqual(dt.tzoffset(), -28800) # Timezone by name, with daylightsaving in effect dt = DateTime('Tue, 24 Aug 2001 09:41:03 PST') self.assertEqual(dt.tzoffset(), -25200) # A negative numerical timezone dt = DateTime('Tue, 24 Jul 2001 09:41:03 -0400') self.assertEqual(dt.tzoffset(), -14400) # A positive numerical timzone dt = DateTime('Tue, 6 Dec 1966 01:41:03 +0200') self.assertEqual(dt.tzoffset(), 7200) # A negative numerical timezone with minutes. dt = DateTime('Tue, 24 Jul 2001 09:41:03 -0637') self.assertEqual(dt.tzoffset(), -23820) # A positive numerical timezone with minutes. dt = DateTime('Tue, 24 Jul 2001 09:41:03 +0425') self.assertEqual(dt.tzoffset(), 15900) def testISO8601(self): # ISO8601 reference dates ref0 = DateTime('2002/5/2 8:00am GMT') ref1 = DateTime('2002/5/2 8:00am US/Eastern') ref2 = DateTime('2006/11/6 10:30 GMT') ref3 = DateTime('2004/06/14 14:30:15 GMT-3') ref4 = DateTime('2006/01/01 GMT') # Basic tests # Though this is timezone naive and according to specification should # be interpreted in the local timezone, to preserve backwards # compatibility with previously expected behaviour. isoDt = DateTime('2002-05-02T08:00:00') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-05-02T08:00:00Z') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-05-02T08:00:00+00:00') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-05-02T08:00:00-04:00') self.assertTrue(ref1.equalTo(isoDt)) isoDt = DateTime('2002-05-02 08:00:00-04:00') self.assertTrue(ref1.equalTo(isoDt)) # Bug 1386: the colon in the timezone offset is optional isoDt = DateTime('2002-05-02T08:00:00-0400') self.assertTrue(ref1.equalTo(isoDt)) # Bug 2191: date reduced formats isoDt = DateTime('2006-01-01') self.assertTrue(ref4.equalTo(isoDt)) isoDt = DateTime('200601-01') self.assertTrue(ref4.equalTo(isoDt)) isoDt = DateTime('20060101') self.assertTrue(ref4.equalTo(isoDt)) isoDt = DateTime('2006-01') self.assertTrue(ref4.equalTo(isoDt)) isoDt = DateTime('200601') self.assertTrue(ref4.equalTo(isoDt)) isoDt = DateTime('2006') self.assertTrue(ref4.equalTo(isoDt)) # Bug 2191: date/time separators are also optional isoDt = DateTime('20020502T08:00:00') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-05-02T080000') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('20020502T080000') self.assertTrue(ref0.equalTo(isoDt)) # Bug 2191: timezones with only one digit for hour isoDt = DateTime('20020502T080000+0') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('20020502 080000-4') self.assertTrue(ref1.equalTo(isoDt)) isoDt = DateTime('20020502T080000-400') self.assertTrue(ref1.equalTo(isoDt)) isoDt = DateTime('20020502T080000-4:00') self.assertTrue(ref1.equalTo(isoDt)) # Bug 2191: optional seconds/minutes isoDt = DateTime('2002-05-02T0800') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-05-02T08') self.assertTrue(ref0.equalTo(isoDt)) # Bug 2191: week format isoDt = DateTime('2002-W18-4T0800') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002-W184T0800') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002W18-4T0800') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002W184T08') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2004-W25-1T14:30:15-03:00') self.assertTrue(ref3.equalTo(isoDt)) isoDt = DateTime('2004-W25T14:30:15-03:00') self.assertTrue(ref3.equalTo(isoDt)) # Bug 2191: day of year format isoDt = DateTime('2002-122T0800') self.assertTrue(ref0.equalTo(isoDt)) isoDt = DateTime('2002122T0800') self.assertTrue(ref0.equalTo(isoDt)) # Bug 2191: hours/minutes fractions isoDt = DateTime('2006-11-06T10.5') self.assertTrue(ref2.equalTo(isoDt)) isoDt = DateTime('2006-11-06T10,5') self.assertTrue(ref2.equalTo(isoDt)) isoDt = DateTime('20040614T1430.25-3') self.assertTrue(ref3.equalTo(isoDt)) isoDt = DateTime('2004-06-14T1430,25-3') self.assertTrue(ref3.equalTo(isoDt)) isoDt = DateTime('2004-06-14T14:30.25-3') self.assertTrue(ref3.equalTo(isoDt)) isoDt = DateTime('20040614T14:30,25-3') self.assertTrue(ref3.equalTo(isoDt)) # ISO8601 standard format iso8601_string = '2002-05-02T08:00:00-04:00' iso8601DT = DateTime(iso8601_string) self.assertEqual(iso8601_string, iso8601DT.ISO8601()) # ISO format with no timezone isoDt = DateTime('2006-01-01 00:00:00') self.assertTrue(ref4.equalTo(isoDt)) def testJulianWeek(self): # Check JulianDayWeek function fn = os.path.join(DATADIR, 'julian_testdata.txt') with open(fn, 'r') as fd: lines = fd.readlines() for line in lines: d = DateTime(line[:10]) result_from_mx = tuple(map(int, line[12:-2].split(','))) self.assertEqual(result_from_mx[1], d.week()) def testCopyConstructor(self): d = DateTime('2004/04/04') self.assertEqual(DateTime(d), d) self.assertEqual(str(DateTime(d)), str(d)) d2 = DateTime('1999/04/12 01:00:00') self.assertEqual(DateTime(d2), d2) self.assertEqual(str(DateTime(d2)), str(d2)) def testCopyConstructorPreservesTimezone(self): # test for https://bugs.launchpad.net/zope2/+bug/200007 # This always worked in the local timezone, so we need at least # two tests with different zones to be sure at least one of them # is not local. d = DateTime('2004/04/04') self.assertEqual(DateTime(d).timezone(), d.timezone()) d2 = DateTime('2008/04/25 12:00:00 EST') self.assertEqual(DateTime(d2).timezone(), d2.timezone()) self.assertEqual(str(DateTime(d2)), str(d2)) d3 = DateTime('2008/04/25 12:00:00 PST') self.assertEqual(DateTime(d3).timezone(), d3.timezone()) self.assertEqual(str(DateTime(d3)), str(d3)) def testRFC822(self): # rfc822 conversion dt = DateTime('2002-05-02T08:00:00+00:00') self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 +0000') dt = DateTime('2002-05-02T08:00:00+02:00') self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 +0200') dt = DateTime('2002-05-02T08:00:00-02:00') self.assertEqual(dt.rfc822(), 'Thu, 02 May 2002 08:00:00 -0200') # Checking that conversion from local time is working. dt = DateTime() dts = dt.rfc822().split(' ') times = dts[4].split(':') _isDST = time.localtime(time.time())[8] if _isDST: offset = time.altzone else: offset = time.timezone self.assertEqual(dts[0], dt.aDay() + ',') self.assertEqual(int(dts[1]), dt.day()) self.assertEqual(dts[2], dt.aMonth()) self.assertEqual(int(dts[3]), dt.year()) self.assertEqual(int(times[0]), dt.h_24()) self.assertEqual(int(times[1]), dt.minute()) self.assertEqual(int(times[2]), int(dt.second())) self.assertEqual(dts[5], "%+03d%02d" % divmod((-offset / 60), 60)) def testInternationalDateformat(self): for year in (1990, 2001, 2020): for month in (1, 12): for day in (1, 12, 28, 31): try: d_us = DateTime("%d/%d/%d" % (year, month, day)) except Exception: continue d_int = DateTime("%d.%d.%d" % (day, month, year), datefmt="international") self.assertEqual(d_us, d_int) d_int = DateTime("%d/%d/%d" % (day, month, year), datefmt="international") self.assertEqual(d_us, d_int) def test_intl_format_hyphen(self): d_jan = DateTime('2011-01-11 GMT') d_nov = DateTime('2011-11-01 GMT') d_us = DateTime('11-01-2011 GMT') d_int = DateTime('11-01-2011 GMT', datefmt="international") self.assertNotEqual(d_us, d_int) self.assertEqual(d_us, d_nov) self.assertEqual(d_int, d_jan) def test_calcTimezoneName(self): from DateTime.interfaces import TimeError timezone_dependent_epoch = 2177452800 try: DateTime()._calcTimezoneName(timezone_dependent_epoch, 0) except TimeError: self.fail('Zope Collector issue #484 (negative time bug): ' 'TimeError raised') def testStrftimeTZhandling(self): # strftime timezone testing # This is a test for collector issue #1127 format = '%Y-%m-%d %H:%M %Z' dt = DateTime('Wed, 19 Nov 2003 18:32:07 -0215') dt_string = dt.strftime(format) dt_local = dt.toZone(_findLocalTimeZoneName(0)) dt_localstring = dt_local.strftime(format) self.assertEqual(dt_string, dt_localstring) def testStrftimeFarDates(self): # Checks strftime in dates <= 1900 or >= 2038 dt = DateTime('1900/01/30') self.assertEqual(dt.strftime('%d/%m/%Y'), '30/01/1900') dt = DateTime('2040/01/30') self.assertEqual(dt.strftime('%d/%m/%Y'), '30/01/2040') def testZoneInFarDates(self): # Checks time zone in dates <= 1900 or >= 2038 dt1 = DateTime('2040/01/30 14:33 GMT+1') dt2 = DateTime('2040/01/30 11:33 GMT-2') self.assertEqual(dt1.strftime('%d/%m/%Y %H:%M'), dt2.strftime('%d/%m/%Y %H:%M')) @unittest.skipIf( IS_PYPY, "Using Non-Ascii characters for strftime doesn't work in PyPy" "https://bitbucket.org/pypy/pypy/issues/2161/pypy3-strftime-does-not-accept-unicode" # noqa: E501 line too long ) def testStrftimeUnicode(self): dt = DateTime('2002-05-02T08:00:00+00:00') uchar = b'\xc3\xa0'.decode('utf-8') ok = dt.strftime('Le %d/%m/%Y a %Hh%M').replace('a', uchar) ustr = b'Le %d/%m/%Y \xc3\xa0 %Hh%M'.decode('utf-8') self.assertEqual(dt.strftime(ustr), ok) def testTimezoneNaiveHandling(self): # checks that we assign timezone naivity correctly dt = DateTime('2007-10-04T08:00:00+00:00') self.assertFalse(dt.timezoneNaive(), 'error with naivity handling in __parse_iso8601') dt = DateTime('2007-10-04T08:00:00Z') self.assertFalse(dt.timezoneNaive(), 'error with naivity handling in __parse_iso8601') dt = DateTime('2007-10-04T08:00:00') self.assertTrue(dt.timezoneNaive(), 'error with naivity handling in __parse_iso8601') dt = DateTime('2007/10/04 15:12:33.487618 GMT+1') self.assertFalse(dt.timezoneNaive(), 'error with naivity handling in _parse') dt = DateTime('2007/10/04 15:12:33.487618') self.assertTrue(dt.timezoneNaive(), 'error with naivity handling in _parse') dt = DateTime() self.assertFalse(dt.timezoneNaive(), 'error with naivity for current time') s = '2007-10-04T08:00:00' dt = DateTime(s) self.assertEqual(s, dt.ISO8601()) s = '2007-10-04T08:00:00+00:00' dt = DateTime(s) self.assertEqual(s, dt.ISO8601()) def testConversions(self): sdt0 = datetime.now() # this is a timezone naive datetime dt0 = DateTime(sdt0) self.assertTrue(dt0.timezoneNaive(), (sdt0, dt0)) sdt1 = datetime(2007, 10, 4, 18, 14, 42, 580, pytz.utc) dt1 = DateTime(sdt1) self.assertFalse(dt1.timezoneNaive(), (sdt1, dt1)) # convert back sdt2 = dt0.asdatetime() self.assertEqual(sdt0, sdt2) sdt3 = dt1.utcdatetime() # this returns a timezone naive datetime self.assertEqual(sdt1.hour, sdt3.hour) dt4 = DateTime('2007-10-04T10:00:00+05:00') sdt4 = datetime(2007, 10, 4, 5, 0) self.assertEqual(dt4.utcdatetime(), sdt4) self.assertEqual(dt4.asdatetime(), sdt4.replace(tzinfo=pytz.utc)) dt5 = DateTime('2007-10-23 10:00:00 US/Eastern') tz = pytz.timezone('US/Eastern') sdt5 = datetime(2007, 10, 23, 10, 0, tzinfo=tz) dt6 = DateTime(sdt5) self.assertEqual(dt5.asdatetime(), sdt5) self.assertEqual(dt6.asdatetime(), sdt5) self.assertEqual(dt5, dt6) self.assertEqual(dt5.asdatetime().tzinfo, tz) self.assertEqual(dt6.asdatetime().tzinfo, tz) def testBasicTZ(self): # psycopg2 supplies it's own tzinfo instances, with no `zone` attribute tz = FixedOffset(60, 'GMT+1') dt1 = datetime(2008, 8, 5, 12, 0, tzinfo=tz) DT = DateTime(dt1) dt2 = DT.asdatetime() offset1 = dt1.tzinfo.utcoffset(dt1) offset2 = dt2.tzinfo.utcoffset(dt2) self.assertEqual(offset1, offset2) def testEDTTimezone(self): # should be able to parse EDT timezones: see lp:599856. dt = DateTime("Mon, 28 Jun 2010 10:12:25 EDT") self.assertEqual(dt.Day(), 'Monday') self.assertEqual(dt.day(), 28) self.assertEqual(dt.Month(), 'June') self.assertEqual(dt.timezone(), 'GMT-4') def testParseISO8601(self): parsed = DateTime()._parse_iso8601('2010-10-10') self.assertEqual(parsed, (2010, 10, 10, 0, 0, 0, 'GMT+0000')) def test_interface(self): from DateTime.interfaces import IDateTime self.assertTrue(IDateTime.providedBy(DateTime())) def test_security(self): dt = DateTime() self.assertEqual(dt.__roles__, None) self.assertEqual(dt.__allow_access_to_unprotected_subobjects__, 1) @unittest.skipUnless(PY3K, 'format method is Python 3 only') def test_format(self): dt = DateTime(1968, 3, 10, 23, 45, 0, 'Europe/Vienna') fmt = '%d.%m.%Y %H:%M' result = dt.strftime(fmt) unformatted_result = '1968/03/10 23:45:00 Europe/Vienna' self.assertEqual(result, '{:%d.%m.%Y %H:%M}'.format(dt)) self.assertEqual(unformatted_result, '{:}'.format(dt)) self.assertEqual(unformatted_result, '{}'.format(dt)) if sys.version_info >= (3, 6): # f-strings are new in Python 3.6 PY3 eval("self.assertEqual(result, f'{dt:{fmt}}')") eval("self.assertEqual(unformatted_result ,f'{dt:}')") eval("self.assertEqual(unformatted_result, f'{dt}')") def test_suite(): import doctest return unittest.TestSuite([ unittest.makeSuite(DateTimeTests), doctest.DocFileSuite('DateTime.txt', package='DateTime'), doctest.DocFileSuite('pytz.txt', package='DateTime'), ])