from __future__ import annotations import base64 import contextlib import dataclasses import importlib.metadata import io import json import os import pathlib import pickle import re import shutil import struct import tempfile import unittest from datetime import date, datetime, time, timedelta, timezone from functools import cached_property from test.test_zoneinfo import _support as test_support from test.test_zoneinfo._support import OS_ENV_LOCK, TZPATH_TEST_LOCK, ZoneInfoTestBase from test.support.import_helper import import_module lzma = import_module('lzma') py_zoneinfo, c_zoneinfo = test_support.get_modules() try: importlib.metadata.metadata("tzdata") HAS_TZDATA_PKG = True except importlib.metadata.PackageNotFoundError: HAS_TZDATA_PKG = False ZONEINFO_DATA = None ZONEINFO_DATA_V1 = None TEMP_DIR = None DATA_DIR = pathlib.Path(__file__).parent / "data" ZONEINFO_JSON = DATA_DIR / "zoneinfo_data.json" # Useful constants ZERO = timedelta(0) ONE_H = timedelta(hours=1) def setUpModule(): global TEMP_DIR global ZONEINFO_DATA global ZONEINFO_DATA_V1 TEMP_DIR = pathlib.Path(tempfile.mkdtemp(prefix="zoneinfo")) ZONEINFO_DATA = ZoneInfoData(ZONEINFO_JSON, TEMP_DIR / "v2") ZONEINFO_DATA_V1 = ZoneInfoData(ZONEINFO_JSON, TEMP_DIR / "v1", v1=True) def tearDownModule(): shutil.rmtree(TEMP_DIR) class TzPathUserMixin: """ Adds a setUp() and tearDown() to make TZPATH manipulations thread-safe. Any tests that require manipulation of the TZPATH global are necessarily thread unsafe, so we will acquire a lock and reset the TZPATH variable to the default state before each test and release the lock after the test is through. """ @property def tzpath(self): # pragma: nocover return None @property def block_tzdata(self): return True def setUp(self): with contextlib.ExitStack() as stack: stack.enter_context( self.tzpath_context( self.tzpath, block_tzdata=self.block_tzdata, lock=TZPATH_TEST_LOCK, ) ) self.addCleanup(stack.pop_all().close) super().setUp() class DatetimeSubclassMixin: """ Replaces all ZoneTransition transition dates with a datetime subclass. """ class DatetimeSubclass(datetime): @classmethod def from_datetime(cls, dt): return cls( dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, tzinfo=dt.tzinfo, fold=dt.fold, ) def load_transition_examples(self, key): transition_examples = super().load_transition_examples(key) for zt in transition_examples: dt = zt.transition new_dt = self.DatetimeSubclass.from_datetime(dt) new_zt = dataclasses.replace(zt, transition=new_dt) yield new_zt class ZoneInfoTest(TzPathUserMixin, ZoneInfoTestBase): module = py_zoneinfo class_name = "ZoneInfo" def setUp(self): super().setUp() # This is necessary because various subclasses pull from different # data sources (e.g. tzdata, V1 files, etc). self.klass.clear_cache() @property def zoneinfo_data(self): return ZONEINFO_DATA @property def tzpath(self): return [self.zoneinfo_data.tzpath] def zone_from_key(self, key): return self.klass(key) def zones(self): return ZoneDumpData.transition_keys() def fixed_offset_zones(self): return ZoneDumpData.fixed_offset_zones() def load_transition_examples(self, key): return ZoneDumpData.load_transition_examples(key) def test_str(self): # Zones constructed with a key must have str(zone) == key for key in self.zones(): with self.subTest(key): zi = self.zone_from_key(key) self.assertEqual(str(zi), key) # Zones with no key constructed should have str(zone) == repr(zone) file_key = self.zoneinfo_data.keys[0] file_path = self.zoneinfo_data.path_from_key(file_key) with open(file_path, "rb") as f: with self.subTest(test_name="Repr test", path=file_path): zi_ff = self.klass.from_file(f) self.assertEqual(str(zi_ff), repr(zi_ff)) def test_repr(self): # The repr is not guaranteed, but I think we can insist that it at # least contain the name of the class. key = next(iter(self.zones())) zi = self.klass(key) class_name = self.class_name with self.subTest(name="from key"): self.assertRegex(repr(zi), class_name) file_key = self.zoneinfo_data.keys[0] file_path = self.zoneinfo_data.path_from_key(file_key) with open(file_path, "rb") as f: zi_ff = self.klass.from_file(f, key=file_key) with self.subTest(name="from file with key"): self.assertRegex(repr(zi_ff), class_name) with open(file_path, "rb") as f: zi_ff_nk = self.klass.from_file(f) with self.subTest(name="from file without key"): self.assertRegex(repr(zi_ff_nk), class_name) def test_key_attribute(self): key = next(iter(self.zones())) def from_file_nokey(key): with open(self.zoneinfo_data.path_from_key(key), "rb") as f: return self.klass.from_file(f) constructors = ( ("Primary constructor", self.klass, key), ("no_cache", self.klass.no_cache, key), ("from_file", from_file_nokey, None), ) for msg, constructor, expected in constructors: zi = constructor(key) # Ensure that the key attribute is set to the input to ``key`` with self.subTest(msg): self.assertEqual(zi.key, expected) # Ensure that the key attribute is read-only with self.subTest(f"{msg}: readonly"): with self.assertRaises(AttributeError): zi.key = "Some/Value" def test_bad_keys(self): bad_keys = [ "Eurasia/Badzone", # Plausible but does not exist "BZQ", "America.Los_Angeles", "🇨🇦", # Non-ascii "America/New\ud800York", # Contains surrogate character ] for bad_key in bad_keys: with self.assertRaises(self.module.ZoneInfoNotFoundError): self.klass(bad_key) def test_bad_keys_paths(self): bad_keys = [ "/America/Los_Angeles", # Absolute path "America/Los_Angeles/", # Trailing slash - not normalized "../zoneinfo/America/Los_Angeles", # Traverses above TZPATH "America/../America/Los_Angeles", # Not normalized "America/./Los_Angeles", ] for bad_key in bad_keys: with self.assertRaises(ValueError): self.klass(bad_key) def test_bad_zones(self): bad_zones = [ b"", # Empty file b"AAAA3" + b" " * 15, # Bad magic ] for bad_zone in bad_zones: fobj = io.BytesIO(bad_zone) with self.assertRaises(ValueError): self.klass.from_file(fobj) def test_fromutc_errors(self): key = next(iter(self.zones())) zone = self.zone_from_key(key) bad_values = [ (datetime(2019, 1, 1, tzinfo=timezone.utc), ValueError), (datetime(2019, 1, 1), ValueError), (date(2019, 1, 1), TypeError), (time(0), TypeError), (0, TypeError), ("2019-01-01", TypeError), ] for val, exc_type in bad_values: with self.subTest(val=val): with self.assertRaises(exc_type): zone.fromutc(val) def test_utc(self): zi = self.klass("UTC") dt = datetime(2020, 1, 1, tzinfo=zi) self.assertEqual(dt.utcoffset(), ZERO) self.assertEqual(dt.dst(), ZERO) self.assertEqual(dt.tzname(), "UTC") def test_unambiguous(self): test_cases = [] for key in self.zones(): for zone_transition in self.load_transition_examples(key): test_cases.append( ( key, zone_transition.transition - timedelta(days=2), zone_transition.offset_before, ) ) test_cases.append( ( key, zone_transition.transition + timedelta(days=2), zone_transition.offset_after, ) ) for key, dt, offset in test_cases: with self.subTest(key=key, dt=dt, offset=offset): tzi = self.zone_from_key(key) dt = dt.replace(tzinfo=tzi) self.assertEqual(dt.tzname(), offset.tzname, dt) self.assertEqual(dt.utcoffset(), offset.utcoffset, dt) self.assertEqual(dt.dst(), offset.dst, dt) def test_folds_and_gaps(self): test_cases = [] for key in self.zones(): tests = {"folds": [], "gaps": []} for zt in self.load_transition_examples(key): if zt.fold: test_group = tests["folds"] elif zt.gap: test_group = tests["gaps"] else: # Assign a random variable here to disable the peephole # optimizer so that coverage can see this line. # See bpo-2506 for more information. no_peephole_opt = None continue # Cases are of the form key, dt, fold, offset dt = zt.anomaly_start - timedelta(seconds=1) test_group.append((dt, 0, zt.offset_before)) test_group.append((dt, 1, zt.offset_before)) dt = zt.anomaly_start test_group.append((dt, 0, zt.offset_before)) test_group.append((dt, 1, zt.offset_after)) dt = zt.anomaly_start + timedelta(seconds=1) test_group.append((dt, 0, zt.offset_before)) test_group.append((dt, 1, zt.offset_after)) dt = zt.anomaly_end - timedelta(seconds=1) test_group.append((dt, 0, zt.offset_before)) test_group.append((dt, 1, zt.offset_after)) dt = zt.anomaly_end test_group.append((dt, 0, zt.offset_after)) test_group.append((dt, 1, zt.offset_after)) dt = zt.anomaly_end + timedelta(seconds=1) test_group.append((dt, 0, zt.offset_after)) test_group.append((dt, 1, zt.offset_after)) for grp, test_group in tests.items(): test_cases.append(((key, grp), test_group)) for (key, grp), tests in test_cases: with self.subTest(key=key, grp=grp): tzi = self.zone_from_key(key) for dt, fold, offset in tests: dt = dt.replace(fold=fold, tzinfo=tzi) self.assertEqual(dt.tzname(), offset.tzname, dt) self.assertEqual(dt.utcoffset(), offset.utcoffset, dt) self.assertEqual(dt.dst(), offset.dst, dt) def test_folds_from_utc(self): for key in self.zones(): zi = self.zone_from_key(key) with self.subTest(key=key): for zt in self.load_transition_examples(key): if not zt.fold: continue dt_utc = zt.transition_utc dt_before_utc = dt_utc - timedelta(seconds=1) dt_after_utc = dt_utc + timedelta(seconds=1) dt_before = dt_before_utc.astimezone(zi) self.assertEqual(dt_before.fold, 0, (dt_before, dt_utc)) dt_after = dt_after_utc.astimezone(zi) self.assertEqual(dt_after.fold, 1, (dt_after, dt_utc)) def test_time_variable_offset(self): # self.zones() only ever returns variable-offset zones for key in self.zones(): zi = self.zone_from_key(key) t = time(11, 15, 1, 34471, tzinfo=zi) with self.subTest(key=key): self.assertIs(t.tzname(), None) self.assertIs(t.utcoffset(), None) self.assertIs(t.dst(), None) def test_time_fixed_offset(self): for key, offset in self.fixed_offset_zones(): zi = self.zone_from_key(key) t = time(11, 15, 1, 34471, tzinfo=zi) with self.subTest(key=key): self.assertEqual(t.tzname(), offset.tzname) self.assertEqual(t.utcoffset(), offset.utcoffset) self.assertEqual(t.dst(), offset.dst) class CZoneInfoTest(ZoneInfoTest): module = c_zoneinfo def test_fold_mutate(self): """Test that fold isn't mutated when no change is necessary. The underlying C API is capable of mutating datetime objects, and may rely on the fact that addition of a datetime object returns a new datetime; this test ensures that the input datetime to fromutc is not mutated. """ def to_subclass(dt): class SameAddSubclass(type(dt)): def __add__(self, other): if other == timedelta(0): return self return super().__add__(other) # pragma: nocover return SameAddSubclass( dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, fold=dt.fold, tzinfo=dt.tzinfo, ) subclass = [False, True] key = "Europe/London" zi = self.zone_from_key(key) for zt in self.load_transition_examples(key): if zt.fold and zt.offset_after.utcoffset == ZERO: example = zt.transition_utc.replace(tzinfo=zi) break for subclass in [False, True]: if subclass: dt = to_subclass(example) else: dt = example with self.subTest(subclass=subclass): dt_fromutc = zi.fromutc(dt) self.assertEqual(dt_fromutc.fold, 1) self.assertEqual(dt.fold, 0) class ZoneInfoDatetimeSubclassTest(DatetimeSubclassMixin, ZoneInfoTest): pass class CZoneInfoDatetimeSubclassTest(DatetimeSubclassMixin, CZoneInfoTest): pass class ZoneInfoSubclassTest(ZoneInfoTest): @classmethod def setUpClass(cls): super().setUpClass() class ZISubclass(cls.klass): pass cls.class_name = "ZISubclass" cls.parent_klass = cls.klass cls.klass = ZISubclass def test_subclass_own_cache(self): base_obj = self.parent_klass("Europe/London") sub_obj = self.klass("Europe/London") self.assertIsNot(base_obj, sub_obj) self.assertIsInstance(base_obj, self.parent_klass) self.assertIsInstance(sub_obj, self.klass) class CZoneInfoSubclassTest(ZoneInfoSubclassTest): module = c_zoneinfo class ZoneInfoV1Test(ZoneInfoTest): @property def zoneinfo_data(self): return ZONEINFO_DATA_V1 def load_transition_examples(self, key): # We will discard zdump examples outside the range epoch +/- 2**31, # because they are not well-supported in Version 1 files. epoch = datetime(1970, 1, 1) max_offset_32 = timedelta(seconds=2 ** 31) min_dt = epoch - max_offset_32 max_dt = epoch + max_offset_32 for zt in ZoneDumpData.load_transition_examples(key): if min_dt <= zt.transition <= max_dt: yield zt class CZoneInfoV1Test(ZoneInfoV1Test): module = c_zoneinfo @unittest.skipIf( not HAS_TZDATA_PKG, "Skipping tzdata-specific tests: tzdata not installed" ) class TZDataTests(ZoneInfoTest): """ Runs all the ZoneInfoTest tests, but against the tzdata package NOTE: The ZoneDumpData has frozen test data, but tzdata will update, so some of the tests (particularly those related to the far future) may break in the event that the time zone policies in the relevant time zones change. """ @property def tzpath(self): return [] @property def block_tzdata(self): return False def zone_from_key(self, key): return self.klass(key=key) @unittest.skipIf( not HAS_TZDATA_PKG, "Skipping tzdata-specific tests: tzdata not installed" ) class CTZDataTests(TZDataTests): module = c_zoneinfo class WeirdZoneTest(ZoneInfoTestBase): module = py_zoneinfo def test_one_transition(self): LMT = ZoneOffset("LMT", -timedelta(hours=6, minutes=31, seconds=2)) STD = ZoneOffset("STD", -timedelta(hours=6)) transitions = [ ZoneTransition(datetime(1883, 6, 9, 14), LMT, STD), ] after = "STD6" zf = self.construct_zone(transitions, after) zi = self.klass.from_file(zf) dt0 = datetime(1883, 6, 9, 1, tzinfo=zi) dt1 = datetime(1883, 6, 10, 1, tzinfo=zi) for dt, offset in [(dt0, LMT), (dt1, STD)]: with self.subTest(name="local", dt=dt): self.assertEqual(dt.tzname(), offset.tzname) self.assertEqual(dt.utcoffset(), offset.utcoffset) self.assertEqual(dt.dst(), offset.dst) dts = [ ( datetime(1883, 6, 9, 1, tzinfo=zi), datetime(1883, 6, 9, 7, 31, 2, tzinfo=timezone.utc), ), ( datetime(2010, 4, 1, 12, tzinfo=zi), datetime(2010, 4, 1, 18, tzinfo=timezone.utc), ), ] for dt_local, dt_utc in dts: with self.subTest(name="fromutc", dt=dt_local): dt_actual = dt_utc.astimezone(zi) self.assertEqual(dt_actual, dt_local) dt_utc_actual = dt_local.astimezone(timezone.utc) self.assertEqual(dt_utc_actual, dt_utc) def test_one_zone_dst(self): DST = ZoneOffset("DST", ONE_H, ONE_H) transitions = [ ZoneTransition(datetime(1970, 1, 1), DST, DST), ] after = "STD0DST-1,0/0,J365/25" zf = self.construct_zone(transitions, after) zi = self.klass.from_file(zf) dts = [ datetime(1900, 3, 1), datetime(1965, 9, 12), datetime(1970, 1, 1), datetime(2010, 11, 3), datetime(2040, 1, 1), ] for dt in dts: dt = dt.replace(tzinfo=zi) with self.subTest(dt=dt): self.assertEqual(dt.tzname(), DST.tzname) self.assertEqual(dt.utcoffset(), DST.utcoffset) self.assertEqual(dt.dst(), DST.dst) def test_no_tz_str(self): STD = ZoneOffset("STD", ONE_H, ZERO) DST = ZoneOffset("DST", 2 * ONE_H, ONE_H) transitions = [] for year in range(1996, 2000): transitions.append( ZoneTransition(datetime(year, 3, 1, 2), STD, DST) ) transitions.append( ZoneTransition(datetime(year, 11, 1, 2), DST, STD) ) after = "" zf = self.construct_zone(transitions, after) # According to RFC 8536, local times after the last transition time # with an empty TZ string are unspecified. We will go with "hold the # last transition", but the most we should promise is "doesn't crash." zi = self.klass.from_file(zf) cases = [ (datetime(1995, 1, 1), STD), (datetime(1996, 4, 1), DST), (datetime(1996, 11, 2), STD), (datetime(2001, 1, 1), STD), ] for dt, offset in cases: dt = dt.replace(tzinfo=zi) with self.subTest(dt=dt): self.assertEqual(dt.tzname(), offset.tzname) self.assertEqual(dt.utcoffset(), offset.utcoffset) self.assertEqual(dt.dst(), offset.dst) # Test that offsets return None when using a datetime.time t = time(0, tzinfo=zi) with self.subTest("Testing datetime.time"): self.assertIs(t.tzname(), None) self.assertIs(t.utcoffset(), None) self.assertIs(t.dst(), None) def test_tz_before_only(self): # From RFC 8536 Section 3.2: # # If there are no transitions, local time for all timestamps is # specified by the TZ string in the footer if present and nonempty; # otherwise, it is specified by time type 0. offsets = [ ZoneOffset("STD", ZERO, ZERO), ZoneOffset("DST", ONE_H, ONE_H), ] for offset in offsets: # Phantom transition to set time type 0. transitions = [ ZoneTransition(None, offset, offset), ] after = "" zf = self.construct_zone(transitions, after) zi = self.klass.from_file(zf) dts = [ datetime(1900, 1, 1), datetime(1970, 1, 1), datetime(2000, 1, 1), ] for dt in dts: dt = dt.replace(tzinfo=zi) with self.subTest(offset=offset, dt=dt): self.assertEqual(dt.tzname(), offset.tzname) self.assertEqual(dt.utcoffset(), offset.utcoffset) self.assertEqual(dt.dst(), offset.dst) def test_empty_zone(self): zf = self.construct_zone([], "") with self.assertRaises(ValueError): self.klass.from_file(zf) def test_zone_very_large_timestamp(self): """Test when a transition is in the far past or future. Particularly, this is a concern if something: 1. Attempts to call ``datetime.timestamp`` for a datetime outside of ``[datetime.min, datetime.max]``. 2. Attempts to construct a timedelta outside of ``[timedelta.min, timedelta.max]``. This actually occurs "in the wild", as some time zones on Ubuntu (at least as of 2020) have an initial transition added at ``-2**58``. """ LMT = ZoneOffset("LMT", timedelta(seconds=-968)) GMT = ZoneOffset("GMT", ZERO) transitions = [ (-(1 << 62), LMT, LMT), ZoneTransition(datetime(1912, 1, 1), LMT, GMT), ((1 << 62), GMT, GMT), ] after = "GMT0" zf = self.construct_zone(transitions, after) zi = self.klass.from_file(zf, key="Africa/Abidjan") offset_cases = [ (datetime.min, LMT), (datetime.max, GMT), (datetime(1911, 12, 31), LMT), (datetime(1912, 1, 2), GMT), ] for dt_naive, offset in offset_cases: dt = dt_naive.replace(tzinfo=zi) with self.subTest(name="offset", dt=dt, offset=offset): self.assertEqual(dt.tzname(), offset.tzname) self.assertEqual(dt.utcoffset(), offset.utcoffset) self.assertEqual(dt.dst(), offset.dst) utc_cases = [ (datetime.min, datetime.min + timedelta(seconds=968)), (datetime(1898, 12, 31, 23, 43, 52), datetime(1899, 1, 1)), ( datetime(1911, 12, 31, 23, 59, 59, 999999), datetime(1912, 1, 1, 0, 16, 7, 999999), ), (datetime(1912, 1, 1, 0, 16, 8), datetime(1912, 1, 1, 0, 16, 8)), (datetime(1970, 1, 1), datetime(1970, 1, 1)), (datetime.max, datetime.max), ] for naive_dt, naive_dt_utc in utc_cases: dt = naive_dt.replace(tzinfo=zi) dt_utc = naive_dt_utc.replace(tzinfo=timezone.utc) self.assertEqual(dt_utc.astimezone(zi), dt) self.assertEqual(dt, dt_utc) def test_fixed_offset_phantom_transition(self): UTC = ZoneOffset("UTC", ZERO, ZERO) transitions = [ZoneTransition(datetime(1970, 1, 1), UTC, UTC)] after = "UTC0" zf = self.construct_zone(transitions, after) zi = self.klass.from_file(zf, key="UTC") dt = datetime(2020, 1, 1, tzinfo=zi) with self.subTest("datetime.datetime"): self.assertEqual(dt.tzname(), UTC.tzname) self.assertEqual(dt.utcoffset(), UTC.utcoffset) self.assertEqual(dt.dst(), UTC.dst) t = time(0, tzinfo=zi) with self.subTest("datetime.time"): self.assertEqual(t.tzname(), UTC.tzname) self.assertEqual(t.utcoffset(), UTC.utcoffset) self.assertEqual(t.dst(), UTC.dst) def construct_zone(self, transitions, after=None, version=3): # These are not used for anything, so we're not going to include # them for now. isutc = [] isstd = [] leap_seconds = [] offset_lists = [[], []] trans_times_lists = [[], []] trans_idx_lists = [[], []] v1_range = (-(2 ** 31), 2 ** 31) v2_range = (-(2 ** 63), 2 ** 63) ranges = [v1_range, v2_range] def zt_as_tuple(zt): # zt may be a tuple (timestamp, offset_before, offset_after) or # a ZoneTransition object — this is to allow the timestamp to be # values that are outside the valid range for datetimes but still # valid 64-bit timestamps. if isinstance(zt, tuple): return zt if zt.transition: trans_time = int(zt.transition_utc.timestamp()) else: trans_time = None return (trans_time, zt.offset_before, zt.offset_after) transitions = sorted(map(zt_as_tuple, transitions), key=lambda x: x[0]) for zt in transitions: trans_time, offset_before, offset_after = zt for v, (dt_min, dt_max) in enumerate(ranges): offsets = offset_lists[v] trans_times = trans_times_lists[v] trans_idx = trans_idx_lists[v] if trans_time is not None and not ( dt_min <= trans_time <= dt_max ): continue if offset_before not in offsets: offsets.append(offset_before) if offset_after not in offsets: offsets.append(offset_after) if trans_time is not None: trans_times.append(trans_time) trans_idx.append(offsets.index(offset_after)) isutcnt = len(isutc) isstdcnt = len(isstd) leapcnt = len(leap_seconds) zonefile = io.BytesIO() time_types = ("l", "q") for v in range(min((version, 2))): offsets = offset_lists[v] trans_times = trans_times_lists[v] trans_idx = trans_idx_lists[v] time_type = time_types[v] # Translate the offsets into something closer to the C values abbrstr = bytearray() ttinfos = [] for offset in offsets: utcoff = int(offset.utcoffset.total_seconds()) isdst = bool(offset.dst) abbrind = len(abbrstr) ttinfos.append((utcoff, isdst, abbrind)) abbrstr += offset.tzname.encode("ascii") + b"\x00" abbrstr = bytes(abbrstr) typecnt = len(offsets) timecnt = len(trans_times) charcnt = len(abbrstr) # Write the header zonefile.write(b"TZif") zonefile.write(b"%d" % version) zonefile.write(b" " * 15) zonefile.write( struct.pack( ">6l", isutcnt, isstdcnt, leapcnt, timecnt, typecnt, charcnt ) ) # Now the transition data zonefile.write(struct.pack(f">{timecnt}{time_type}", *trans_times)) zonefile.write(struct.pack(f">{timecnt}B", *trans_idx)) for ttinfo in ttinfos: zonefile.write(struct.pack(">lbb", *ttinfo)) zonefile.write(bytes(abbrstr)) # Now the metadata and leap seconds zonefile.write(struct.pack(f"{isutcnt}b", *isutc)) zonefile.write(struct.pack(f"{isstdcnt}b", *isstd)) zonefile.write(struct.pack(f">{leapcnt}l", *leap_seconds)) # Finally we write the TZ string if we're writing a Version 2+ file if v > 0: zonefile.write(b"\x0A") zonefile.write(after.encode("ascii")) zonefile.write(b"\x0A") zonefile.seek(0) return zonefile class CWeirdZoneTest(WeirdZoneTest): module = c_zoneinfo class TZStrTest(ZoneInfoTestBase): module = py_zoneinfo NORMAL = 0 FOLD = 1 GAP = 2 @classmethod def setUpClass(cls): super().setUpClass() cls._populate_test_cases() cls.populate_tzstr_header() @classmethod def populate_tzstr_header(cls): out = bytearray() # The TZif format always starts with a Version 1 file followed by # the Version 2+ file. In this case, we have no transitions, just # the tzstr in the footer, so up to the footer, the files are # identical and we can just write the same file twice in a row. for _ in range(2): out += b"TZif" # Magic value out += b"3" # Version out += b" " * 15 # Reserved # We will not write any of the manual transition parts out += struct.pack(">6l", 0, 0, 0, 0, 0, 0) cls._tzif_header = bytes(out) def zone_from_tzstr(self, tzstr): """Creates a zoneinfo file following a POSIX rule.""" zonefile = io.BytesIO(self._tzif_header) zonefile.seek(0, 2) # Write the footer zonefile.write(b"\x0A") zonefile.write(tzstr.encode("ascii")) zonefile.write(b"\x0A") zonefile.seek(0) return self.klass.from_file(zonefile, key=tzstr) def test_tzstr_localized(self): for tzstr, cases in self.test_cases.items(): with self.subTest(tzstr=tzstr): zi = self.zone_from_tzstr(tzstr) for dt_naive, offset, _ in cases: dt = dt_naive.replace(tzinfo=zi) with self.subTest(tzstr=tzstr, dt=dt, offset=offset): self.assertEqual(dt.tzname(), offset.tzname) self.assertEqual(dt.utcoffset(), offset.utcoffset) self.assertEqual(dt.dst(), offset.dst) def test_tzstr_from_utc(self): for tzstr, cases in self.test_cases.items(): with self.subTest(tzstr=tzstr): zi = self.zone_from_tzstr(tzstr) for dt_naive, offset, dt_type in cases: if dt_type == self.GAP: continue # Cannot create a gap from UTC dt_utc = (dt_naive - offset.utcoffset).replace( tzinfo=timezone.utc ) # Check that we can go UTC -> Our zone dt_act = dt_utc.astimezone(zi) dt_exp = dt_naive.replace(tzinfo=zi) self.assertEqual(dt_act, dt_exp) if dt_type == self.FOLD: self.assertEqual(dt_act.fold, dt_naive.fold, dt_naive) else: self.assertEqual(dt_act.fold, 0) # Now check that we can go our zone -> UTC dt_act = dt_exp.astimezone(timezone.utc) self.assertEqual(dt_act, dt_utc) def test_invalid_tzstr(self): invalid_tzstrs = [ "PST8PDT", # DST but no transition specified "+11", # Unquoted alphanumeric "GMT,M3.2.0/2,M11.1.0/3", # Transition rule but no DST "GMT0+11,M3.2.0/2,M11.1.0/3", # Unquoted alphanumeric in DST "PST8PDT,M3.2.0/2", # Only one transition rule # Invalid offsets "STD+25", "STD-25", "STD+374", "STD+374DST,M3.2.0/2,M11.1.0/3", "STD+23DST+25,M3.2.0/2,M11.1.0/3", "STD-23DST-25,M3.2.0/2,M11.1.0/3", # Completely invalid dates "AAA4BBB,M1443339,M11.1.0/3", "AAA4BBB,M3.2.0/2,0349309483959c", # Invalid months "AAA4BBB,M13.1.1/2,M1.1.1/2", "AAA4BBB,M1.1.1/2,M13.1.1/2", "AAA4BBB,M0.1.1/2,M1.1.1/2", "AAA4BBB,M1.1.1/2,M0.1.1/2", # Invalid weeks "AAA4BBB,M1.6.1/2,M1.1.1/2", "AAA4BBB,M1.1.1/2,M1.6.1/2", # Invalid weekday "AAA4BBB,M1.1.7/2,M2.1.1/2", "AAA4BBB,M1.1.1/2,M2.1.7/2", # Invalid numeric offset "AAA4BBB,-1/2,20/2", "AAA4BBB,1/2,-1/2", "AAA4BBB,367,20/2", "AAA4BBB,1/2,367/2", # Invalid julian offset "AAA4BBB,J0/2,J20/2", "AAA4BBB,J20/2,J366/2", ] for invalid_tzstr in invalid_tzstrs: with self.subTest(tzstr=invalid_tzstr): # Not necessarily a guaranteed property, but we should show # the problematic TZ string if that's the cause of failure. tzstr_regex = re.escape(invalid_tzstr) with self.assertRaisesRegex(ValueError, tzstr_regex): self.zone_from_tzstr(invalid_tzstr) @classmethod def _populate_test_cases(cls): # This method uses a somewhat unusual style in that it populates the # test cases for each tzstr by using a decorator to automatically call # a function that mutates the current dictionary of test cases. # # The population of the test cases is done in individual functions to # give each set of test cases its own namespace in which to define # its offsets (this way we don't have to worry about variable reuse # causing problems if someone makes a typo). # # The decorator for calling is used to make it more obvious that each # function is actually called (if it's not decorated, it's not called). def call(f): """Decorator to call the addition methods. This will call a function which adds at least one new entry into the `cases` dictionary. The decorator will also assert that something was added to the dictionary. """ prev_len = len(cases) f() assert len(cases) > prev_len, "Function did not add a test case!" NORMAL = cls.NORMAL FOLD = cls.FOLD GAP = cls.GAP cases = {} @call def _add(): # Transition to EDT on the 2nd Sunday in March at 4 AM, and # transition back on the first Sunday in November at 3AM tzstr = "EST5EDT,M3.2.0/4:00,M11.1.0/3:00" EST = ZoneOffset("EST", timedelta(hours=-5), ZERO) EDT = ZoneOffset("EDT", timedelta(hours=-4), ONE_H) cases[tzstr] = ( (datetime(2019, 3, 9), EST, NORMAL), (datetime(2019, 3, 10, 3, 59), EST, NORMAL), (datetime(2019, 3, 10, 4, 0, fold=0), EST, GAP), (datetime(2019, 3, 10, 4, 0, fold=1), EDT, GAP), (datetime(2019, 3, 10, 4, 1, fold=0), EST, GAP), (datetime(2019, 3, 10, 4, 1, fold=1), EDT, GAP), (datetime(2019, 11, 2), EDT, NORMAL), (datetime(2019, 11, 3, 1, 59, fold=1), EDT, NORMAL), (datetime(2019, 11, 3, 2, 0, fold=0), EDT, FOLD), (datetime(2019, 11, 3, 2, 0, fold=1), EST, FOLD), (datetime(2020, 3, 8, 3, 59), EST, NORMAL), (datetime(2020, 3, 8, 4, 0, fold=0), EST, GAP), (datetime(2020, 3, 8, 4, 0, fold=1), EDT, GAP), (datetime(2020, 11, 1, 1, 59, fold=1), EDT, NORMAL), (datetime(2020, 11, 1, 2, 0, fold=0), EDT, FOLD), (datetime(2020, 11, 1, 2, 0, fold=1), EST, FOLD), ) @call def _add(): # Transition to BST happens on the last Sunday in March at 1 AM GMT # and the transition back happens the last Sunday in October at 2AM BST tzstr = "GMT0BST-1,M3.5.0/1:00,M10.5.0/2:00" GMT = ZoneOffset("GMT", ZERO, ZERO) BST = ZoneOffset("BST", ONE_H, ONE_H) cases[tzstr] = ( (datetime(2019, 3, 30), GMT, NORMAL), (datetime(2019, 3, 31, 0, 59), GMT, NORMAL), (datetime(2019, 3, 31, 2, 0), BST, NORMAL), (datetime(2019, 10, 26), BST, NORMAL), (datetime(2019, 10, 27, 0, 59, fold=1), BST, NORMAL), (datetime(2019, 10, 27, 1, 0, fold=0), BST, GAP), (datetime(2019, 10, 27, 2, 0, fold=1), GMT, GAP), (datetime(2020, 3, 29, 0, 59), GMT, NORMAL), (datetime(2020, 3, 29, 2, 0), BST, NORMAL), (datetime(2020, 10, 25, 0, 59, fold=1), BST, NORMAL), (datetime(2020, 10, 25, 1, 0, fold=0), BST, FOLD), (datetime(2020, 10, 25, 2, 0, fold=1), GMT, NORMAL), ) @call def _add(): # Austrialian time zone - DST start is chronologically first tzstr = "AEST-10AEDT,M10.1.0/2,M4.1.0/3" AEST = ZoneOffset("AEST", timedelta(hours=10), ZERO) AEDT = ZoneOffset("AEDT", timedelta(hours=11), ONE_H) cases[tzstr] = ( (datetime(2019, 4, 6), AEDT, NORMAL), (datetime(2019, 4, 7, 1, 59), AEDT, NORMAL), (datetime(2019, 4, 7, 1, 59, fold=1), AEDT, NORMAL), (datetime(2019, 4, 7, 2, 0, fold=0), AEDT, FOLD), (datetime(2019, 4, 7, 2, 1, fold=0), AEDT, FOLD), (datetime(2019, 4, 7, 2, 0, fold=1), AEST, FOLD), (datetime(2019, 4, 7, 2, 1, fold=1), AEST, FOLD), (datetime(2019, 4, 7, 3, 0, fold=0), AEST, NORMAL), (datetime(2019, 4, 7, 3, 0, fold=1), AEST, NORMAL), (datetime(2019, 10, 5, 0), AEST, NORMAL), (datetime(2019, 10, 6, 1, 59), AEST, NORMAL), (datetime(2019, 10, 6, 2, 0, fold=0), AEST, GAP), (datetime(2019, 10, 6, 2, 0, fold=1), AEDT, GAP), (datetime(2019, 10, 6, 3, 0), AEDT, NORMAL), ) @call def _add(): # Irish time zone - negative DST tzstr = "IST-1GMT0,M10.5.0,M3.5.0/1" GMT = ZoneOffset("GMT", ZERO, -ONE_H) IST = ZoneOffset("IST", ONE_H, ZERO) cases[tzstr] = ( (datetime(2019, 3, 30), GMT, NORMAL), (datetime(2019, 3, 31, 0, 59), GMT, NORMAL), (datetime(2019, 3, 31, 2, 0), IST, NORMAL), (datetime(2019, 10, 26), IST, NORMAL), (datetime(2019, 10, 27, 0, 59, fold=1), IST, NORMAL), (datetime(2019, 10, 27, 1, 0, fold=0), IST, FOLD), (datetime(2019, 10, 27, 1, 0, fold=1), GMT, FOLD), (datetime(2019, 10, 27, 2, 0, fold=1), GMT, NORMAL), (datetime(2020, 3, 29, 0, 59), GMT, NORMAL), (datetime(2020, 3, 29, 2, 0), IST, NORMAL), (datetime(2020, 10, 25, 0, 59, fold=1), IST, NORMAL), (datetime(2020, 10, 25, 1, 0, fold=0), IST, FOLD), (datetime(2020, 10, 25, 2, 0, fold=1), GMT, NORMAL), ) @call def _add(): # Pacific/Kosrae: Fixed offset zone with a quoted numerical tzname tzstr = "<+11>-11" cases[tzstr] = ( ( datetime(2020, 1, 1), ZoneOffset("+11", timedelta(hours=11)), NORMAL, ), ) @call def _add(): # Quoted STD and DST, transitions at 24:00 tzstr = "<-04>4<-03>,M9.1.6/24,M4.1.6/24" M04 = ZoneOffset("-04", timedelta(hours=-4)) M03 = ZoneOffset("-03", timedelta(hours=-3), ONE_H) cases[tzstr] = ( (datetime(2020, 5, 1), M04, NORMAL), (datetime(2020, 11, 1), M03, NORMAL), ) @call def _add(): # Permanent daylight saving time is modeled with transitions at 0/0 # and J365/25, as mentioned in RFC 8536 Section 3.3.1 tzstr = "EST5EDT,0/0,J365/25" EDT = ZoneOffset("EDT", timedelta(hours=-4), ONE_H) cases[tzstr] = ( (datetime(2019, 1, 1), EDT, NORMAL), (datetime(2019, 6, 1), EDT, NORMAL), (datetime(2019, 12, 31, 23, 59, 59, 999999), EDT, NORMAL), (datetime(2020, 1, 1), EDT, NORMAL), (datetime(2020, 3, 1), EDT, NORMAL), (datetime(2020, 6, 1), EDT, NORMAL), (datetime(2020, 12, 31, 23, 59, 59, 999999), EDT, NORMAL), (datetime(2400, 1, 1), EDT, NORMAL), (datetime(2400, 3, 1), EDT, NORMAL), (datetime(2400, 12, 31, 23, 59, 59, 999999), EDT, NORMAL), ) @call def _add(): # Transitions on March 1st and November 1st of each year tzstr = "AAA3BBB,J60/12,J305/12" AAA = ZoneOffset("AAA", timedelta(hours=-3)) BBB = ZoneOffset("BBB", timedelta(hours=-2), ONE_H) cases[tzstr] = ( (datetime(2019, 1, 1), AAA, NORMAL), (datetime(2019, 2, 28), AAA, NORMAL), (datetime(2019, 3, 1, 11, 59), AAA, NORMAL), (datetime(2019, 3, 1, 12, fold=0), AAA, GAP), (datetime(2019, 3, 1, 12, fold=1), BBB, GAP), (datetime(2019, 3, 1, 13), BBB, NORMAL), (datetime(2019, 11, 1, 10, 59), BBB, NORMAL), (datetime(2019, 11, 1, 11, fold=0), BBB, FOLD), (datetime(2019, 11, 1, 11, fold=1), AAA, FOLD), (datetime(2019, 11, 1, 12), AAA, NORMAL), (datetime(2019, 12, 31, 23, 59, 59, 999999), AAA, NORMAL), (datetime(2020, 1, 1), AAA, NORMAL), (datetime(2020, 2, 29), AAA, NORMAL), (datetime(2020, 3, 1, 11, 59), AAA, NORMAL), (datetime(2020, 3, 1, 12, fold=0), AAA, GAP), (datetime(2020, 3, 1, 12, fold=1), BBB, GAP), (datetime(2020, 3, 1, 13), BBB, NORMAL), (datetime(2020, 11, 1, 10, 59), BBB, NORMAL), (datetime(2020, 11, 1, 11, fold=0), BBB, FOLD), (datetime(2020, 11, 1, 11, fold=1), AAA, FOLD), (datetime(2020, 11, 1, 12), AAA, NORMAL), (datetime(2020, 12, 31, 23, 59, 59, 999999), AAA, NORMAL), ) @call def _add(): # Taken from America/Godthab, this rule has a transition on the # Saturday before the last Sunday of March and October, at 22:00 # and 23:00, respectively. This is encoded with negative start # and end transition times. tzstr = "<-03>3<-02>,M3.5.0/-2,M10.5.0/-1" N03 = ZoneOffset("-03", timedelta(hours=-3)) N02 = ZoneOffset("-02", timedelta(hours=-2), ONE_H) cases[tzstr] = ( (datetime(2020, 3, 27), N03, NORMAL), (datetime(2020, 3, 28, 21, 59, 59), N03, NORMAL), (datetime(2020, 3, 28, 22, fold=0), N03, GAP), (datetime(2020, 3, 28, 22, fold=1), N02, GAP), (datetime(2020, 3, 28, 23), N02, NORMAL), (datetime(2020, 10, 24, 21), N02, NORMAL), (datetime(2020, 10, 24, 22, fold=0), N02, FOLD), (datetime(2020, 10, 24, 22, fold=1), N03, FOLD), (datetime(2020, 10, 24, 23), N03, NORMAL), ) @call def _add(): # Transition times with minutes and seconds tzstr = "AAA3BBB,M3.2.0/01:30,M11.1.0/02:15:45" AAA = ZoneOffset("AAA", timedelta(hours=-3)) BBB = ZoneOffset("BBB", timedelta(hours=-2), ONE_H) cases[tzstr] = ( (datetime(2012, 3, 11, 1, 0), AAA, NORMAL), (datetime(2012, 3, 11, 1, 30, fold=0), AAA, GAP), (datetime(2012, 3, 11, 1, 30, fold=1), BBB, GAP), (datetime(2012, 3, 11, 2, 30), BBB, NORMAL), (datetime(2012, 11, 4, 1, 15, 44, 999999), BBB, NORMAL), (datetime(2012, 11, 4, 1, 15, 45, fold=0), BBB, FOLD), (datetime(2012, 11, 4, 1, 15, 45, fold=1), AAA, FOLD), (datetime(2012, 11, 4, 2, 15, 45), AAA, NORMAL), ) cls.test_cases = cases class CTZStrTest(TZStrTest): module = c_zoneinfo class ZoneInfoCacheTest(TzPathUserMixin, ZoneInfoTestBase): module = py_zoneinfo def setUp(self): self.klass.clear_cache() super().setUp() @property def zoneinfo_data(self): return ZONEINFO_DATA @property def tzpath(self): return [self.zoneinfo_data.tzpath] def test_ephemeral_zones(self): self.assertIs( self.klass("America/Los_Angeles"), self.klass("America/Los_Angeles") ) def test_strong_refs(self): tz0 = self.klass("Australia/Sydney") tz1 = self.klass("Australia/Sydney") self.assertIs(tz0, tz1) def test_no_cache(self): tz0 = self.klass("Europe/Lisbon") tz1 = self.klass.no_cache("Europe/Lisbon") self.assertIsNot(tz0, tz1) def test_cache_reset_tzpath(self): """Test that the cache persists when tzpath has been changed. The PEP specifies that as long as a reference exists to one zone with a given key, the primary constructor must continue to return the same object. """ zi0 = self.klass("America/Los_Angeles") with self.tzpath_context([]): zi1 = self.klass("America/Los_Angeles") self.assertIs(zi0, zi1) def test_clear_cache_explicit_none(self): la0 = self.klass("America/Los_Angeles") self.klass.clear_cache(only_keys=None) la1 = self.klass("America/Los_Angeles") self.assertIsNot(la0, la1) def test_clear_cache_one_key(self): """Tests that you can clear a single key from the cache.""" la0 = self.klass("America/Los_Angeles") dub0 = self.klass("Europe/Dublin") self.klass.clear_cache(only_keys=["America/Los_Angeles"]) la1 = self.klass("America/Los_Angeles") dub1 = self.klass("Europe/Dublin") self.assertIsNot(la0, la1) self.assertIs(dub0, dub1) def test_clear_cache_two_keys(self): la0 = self.klass("America/Los_Angeles") dub0 = self.klass("Europe/Dublin") tok0 = self.klass("Asia/Tokyo") self.klass.clear_cache( only_keys=["America/Los_Angeles", "Europe/Dublin"] ) la1 = self.klass("America/Los_Angeles") dub1 = self.klass("Europe/Dublin") tok1 = self.klass("Asia/Tokyo") self.assertIsNot(la0, la1) self.assertIsNot(dub0, dub1) self.assertIs(tok0, tok1) class CZoneInfoCacheTest(ZoneInfoCacheTest): module = c_zoneinfo class ZoneInfoPickleTest(TzPathUserMixin, ZoneInfoTestBase): module = py_zoneinfo def setUp(self): self.klass.clear_cache() with contextlib.ExitStack() as stack: stack.enter_context(test_support.set_zoneinfo_module(self.module)) self.addCleanup(stack.pop_all().close) super().setUp() @property def zoneinfo_data(self): return ZONEINFO_DATA @property def tzpath(self): return [self.zoneinfo_data.tzpath] def test_cache_hit(self): for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(proto=proto): zi_in = self.klass("Europe/Dublin") pkl = pickle.dumps(zi_in, protocol=proto) zi_rt = pickle.loads(pkl) with self.subTest(test="Is non-pickled ZoneInfo"): self.assertIs(zi_in, zi_rt) zi_rt2 = pickle.loads(pkl) with self.subTest(test="Is unpickled ZoneInfo"): self.assertIs(zi_rt, zi_rt2) def test_cache_miss(self): for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(proto=proto): zi_in = self.klass("Europe/Dublin") pkl = pickle.dumps(zi_in, protocol=proto) del zi_in self.klass.clear_cache() # Induce a cache miss zi_rt = pickle.loads(pkl) zi_rt2 = pickle.loads(pkl) self.assertIs(zi_rt, zi_rt2) def test_no_cache(self): for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(proto=proto): zi_no_cache = self.klass.no_cache("Europe/Dublin") pkl = pickle.dumps(zi_no_cache, protocol=proto) zi_rt = pickle.loads(pkl) with self.subTest(test="Not the pickled object"): self.assertIsNot(zi_rt, zi_no_cache) zi_rt2 = pickle.loads(pkl) with self.subTest(test="Not a second unpickled object"): self.assertIsNot(zi_rt, zi_rt2) zi_cache = self.klass("Europe/Dublin") with self.subTest(test="Not a cached object"): self.assertIsNot(zi_rt, zi_cache) def test_from_file(self): key = "Europe/Dublin" with open(self.zoneinfo_data.path_from_key(key), "rb") as f: zi_nokey = self.klass.from_file(f) f.seek(0) zi_key = self.klass.from_file(f, key=key) test_cases = [ (zi_key, "ZoneInfo with key"), (zi_nokey, "ZoneInfo without key"), ] for zi, test_name in test_cases: for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(test_name=test_name, proto=proto): with self.assertRaises(pickle.PicklingError): pickle.dumps(zi, protocol=proto) def test_pickle_after_from_file(self): # This may be a bit of paranoia, but this test is to ensure that no # global state is maintained in order to handle the pickle cache and # from_file behavior, and that it is possible to interweave the # constructors of each of these and pickling/unpickling without issues. for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(proto=proto): key = "Europe/Dublin" zi = self.klass(key) pkl_0 = pickle.dumps(zi, protocol=proto) zi_rt_0 = pickle.loads(pkl_0) self.assertIs(zi, zi_rt_0) with open(self.zoneinfo_data.path_from_key(key), "rb") as f: zi_ff = self.klass.from_file(f, key=key) pkl_1 = pickle.dumps(zi, protocol=proto) zi_rt_1 = pickle.loads(pkl_1) self.assertIs(zi, zi_rt_1) with self.assertRaises(pickle.PicklingError): pickle.dumps(zi_ff, protocol=proto) pkl_2 = pickle.dumps(zi, protocol=proto) zi_rt_2 = pickle.loads(pkl_2) self.assertIs(zi, zi_rt_2) class CZoneInfoPickleTest(ZoneInfoPickleTest): module = c_zoneinfo class CallingConventionTest(ZoneInfoTestBase): """Tests for functions with restricted calling conventions.""" module = py_zoneinfo @property def zoneinfo_data(self): return ZONEINFO_DATA def test_from_file(self): with open(self.zoneinfo_data.path_from_key("UTC"), "rb") as f: with self.assertRaises(TypeError): self.klass.from_file(fobj=f) def test_clear_cache(self): with self.assertRaises(TypeError): self.klass.clear_cache(["UTC"]) class CCallingConventionTest(CallingConventionTest): module = c_zoneinfo class TzPathTest(TzPathUserMixin, ZoneInfoTestBase): module = py_zoneinfo @staticmethod @contextlib.contextmanager def python_tzpath_context(value): path_var = "PYTHONTZPATH" try: with OS_ENV_LOCK: old_env = os.environ.get(path_var, None) os.environ[path_var] = value yield finally: if old_env is None: del os.environ[path_var] else: os.environ[path_var] = old_env # pragma: nocover def test_env_variable(self): """Tests that the environment variable works with reset_tzpath.""" new_paths = [ ("", []), ("/etc/zoneinfo", ["/etc/zoneinfo"]), (f"/a/b/c{os.pathsep}/d/e/f", ["/a/b/c", "/d/e/f"]), ] for new_path_var, expected_result in new_paths: with self.python_tzpath_context(new_path_var): with self.subTest(tzpath=new_path_var): self.module.reset_tzpath() tzpath = self.module.TZPATH self.assertSequenceEqual(tzpath, expected_result) def test_env_variable_relative_paths(self): test_cases = [ [("path/to/somewhere",), ()], [ ("/usr/share/zoneinfo", "path/to/somewhere",), ("/usr/share/zoneinfo",), ], [("../relative/path",), ()], [ ("/usr/share/zoneinfo", "../relative/path",), ("/usr/share/zoneinfo",), ], [("path/to/somewhere", "../relative/path",), ()], [ ( "/usr/share/zoneinfo", "path/to/somewhere", "../relative/path", ), ("/usr/share/zoneinfo",), ], ] for input_paths, expected_paths in test_cases: path_var = os.pathsep.join(input_paths) with self.python_tzpath_context(path_var): with self.subTest("warning", path_var=path_var): # Note: Per PEP 615 the warning is implementation-defined # behavior, other implementations need not warn. with self.assertWarns(self.module.InvalidTZPathWarning): self.module.reset_tzpath() tzpath = self.module.TZPATH with self.subTest("filtered", path_var=path_var): self.assertSequenceEqual(tzpath, expected_paths) def test_reset_tzpath_kwarg(self): self.module.reset_tzpath(to=["/a/b/c"]) self.assertSequenceEqual(self.module.TZPATH, ("/a/b/c",)) def test_reset_tzpath_relative_paths(self): bad_values = [ ("path/to/somewhere",), ("/usr/share/zoneinfo", "path/to/somewhere",), ("../relative/path",), ("/usr/share/zoneinfo", "../relative/path",), ("path/to/somewhere", "../relative/path",), ("/usr/share/zoneinfo", "path/to/somewhere", "../relative/path",), ] for input_paths in bad_values: with self.subTest(input_paths=input_paths): with self.assertRaises(ValueError): self.module.reset_tzpath(to=input_paths) def test_tzpath_type_error(self): bad_values = [ "/etc/zoneinfo:/usr/share/zoneinfo", b"/etc/zoneinfo:/usr/share/zoneinfo", 0, ] for bad_value in bad_values: with self.subTest(value=bad_value): with self.assertRaises(TypeError): self.module.reset_tzpath(bad_value) def test_tzpath_attribute(self): tzpath_0 = ["/one", "/two"] tzpath_1 = ["/three"] with self.tzpath_context(tzpath_0): query_0 = self.module.TZPATH with self.tzpath_context(tzpath_1): query_1 = self.module.TZPATH self.assertSequenceEqual(tzpath_0, query_0) self.assertSequenceEqual(tzpath_1, query_1) class CTzPathTest(TzPathTest): module = c_zoneinfo class TestModule(ZoneInfoTestBase): module = py_zoneinfo @property def zoneinfo_data(self): return ZONEINFO_DATA @cached_property def _UTC_bytes(self): zone_file = self.zoneinfo_data.path_from_key("UTC") with open(zone_file, "rb") as f: return f.read() def touch_zone(self, key, tz_root): """Creates a valid TZif file at key under the zoneinfo root tz_root. tz_root must exist, but all folders below that will be created. """ if not os.path.exists(tz_root): raise FileNotFoundError(f"{tz_root} does not exist.") root_dir, *tail = key.rsplit("/", 1) if tail: # If there's no tail, then the first component isn't a dir os.makedirs(os.path.join(tz_root, root_dir), exist_ok=True) zonefile_path = os.path.join(tz_root, key) with open(zonefile_path, "wb") as f: f.write(self._UTC_bytes) def test_getattr_error(self): with self.assertRaises(AttributeError): self.module.NOATTRIBUTE def test_dir_contains_all(self): """dir(self.module) should at least contain everything in __all__.""" module_all_set = set(self.module.__all__) module_dir_set = set(dir(self.module)) difference = module_all_set - module_dir_set self.assertFalse(difference) def test_dir_unique(self): """Test that there are no duplicates in dir(self.module)""" module_dir = dir(self.module) module_unique = set(module_dir) self.assertCountEqual(module_dir, module_unique) def test_available_timezones(self): with self.tzpath_context([self.zoneinfo_data.tzpath]): self.assertTrue(self.zoneinfo_data.keys) # Sanity check available_keys = self.module.available_timezones() zoneinfo_keys = set(self.zoneinfo_data.keys) # If tzdata is not present, zoneinfo_keys == available_keys, # otherwise it should be a subset. union = zoneinfo_keys & available_keys self.assertEqual(zoneinfo_keys, union) def test_available_timezones_weirdzone(self): with tempfile.TemporaryDirectory() as td: # Make a fictional zone at "Mars/Olympus_Mons" self.touch_zone("Mars/Olympus_Mons", td) with self.tzpath_context([td]): available_keys = self.module.available_timezones() self.assertIn("Mars/Olympus_Mons", available_keys) def test_folder_exclusions(self): expected = { "America/Los_Angeles", "America/Santiago", "America/Indiana/Indianapolis", "UTC", "Europe/Paris", "Europe/London", "Asia/Tokyo", "Australia/Sydney", } base_tree = list(expected) posix_tree = [f"posix/{x}" for x in base_tree] right_tree = [f"right/{x}" for x in base_tree] cases = [ ("base_tree", base_tree), ("base_and_posix", base_tree + posix_tree), ("base_and_right", base_tree + right_tree), ("all_trees", base_tree + right_tree + posix_tree), ] with tempfile.TemporaryDirectory() as td: for case_name, tree in cases: tz_root = os.path.join(td, case_name) os.mkdir(tz_root) for key in tree: self.touch_zone(key, tz_root) with self.tzpath_context([tz_root]): with self.subTest(case_name): actual = self.module.available_timezones() self.assertEqual(actual, expected) def test_exclude_posixrules(self): expected = { "America/New_York", "Europe/London", } tree = list(expected) + ["posixrules"] with tempfile.TemporaryDirectory() as td: for key in tree: self.touch_zone(key, td) with self.tzpath_context([td]): actual = self.module.available_timezones() self.assertEqual(actual, expected) class CTestModule(TestModule): module = c_zoneinfo class ExtensionBuiltTest(unittest.TestCase): """Smoke test to ensure that the C and Python extensions are both tested. Because the intention is for the Python and C versions of ZoneInfo to behave identically, these tests necessarily rely on implementation details, so the tests may need to be adjusted if the implementations change. Do not rely on these tests as an indication of stable properties of these classes. """ def test_cache_location(self): # The pure Python version stores caches on attributes, but the C # extension stores them in C globals (at least for now) self.assertFalse(hasattr(c_zoneinfo.ZoneInfo, "_weak_cache")) self.assertTrue(hasattr(py_zoneinfo.ZoneInfo, "_weak_cache")) def test_gc_tracked(self): # The pure Python version is tracked by the GC but (for now) the C # version is not. import gc self.assertTrue(gc.is_tracked(py_zoneinfo.ZoneInfo)) self.assertFalse(gc.is_tracked(c_zoneinfo.ZoneInfo)) @dataclasses.dataclass(frozen=True) class ZoneOffset: tzname: str utcoffset: timedelta dst: timedelta = ZERO @dataclasses.dataclass(frozen=True) class ZoneTransition: transition: datetime offset_before: ZoneOffset offset_after: ZoneOffset @property def transition_utc(self): return (self.transition - self.offset_before.utcoffset).replace( tzinfo=timezone.utc ) @property def fold(self): """Whether this introduces a fold""" return self.offset_before.utcoffset > self.offset_after.utcoffset @property def gap(self): """Whether this introduces a gap""" return self.offset_before.utcoffset < self.offset_after.utcoffset @property def delta(self): return self.offset_after.utcoffset - self.offset_before.utcoffset @property def anomaly_start(self): if self.fold: return self.transition + self.delta else: return self.transition @property def anomaly_end(self): if not self.fold: return self.transition + self.delta else: return self.transition class ZoneInfoData: def __init__(self, source_json, tzpath, v1=False): self.tzpath = pathlib.Path(tzpath) self.keys = [] self.v1 = v1 self._populate_tzpath(source_json) def path_from_key(self, key): return self.tzpath / key def _populate_tzpath(self, source_json): with open(source_json, "rb") as f: zoneinfo_dict = json.load(f) zoneinfo_data = zoneinfo_dict["data"] for key, value in zoneinfo_data.items(): self.keys.append(key) raw_data = self._decode_text(value) if self.v1: data = self._convert_to_v1(raw_data) else: data = raw_data destination = self.path_from_key(key) destination.parent.mkdir(exist_ok=True, parents=True) with open(destination, "wb") as f: f.write(data) def _decode_text(self, contents): raw_data = b"".join(map(str.encode, contents)) decoded = base64.b85decode(raw_data) return lzma.decompress(decoded) def _convert_to_v1(self, contents): assert contents[0:4] == b"TZif", "Invalid TZif data found!" version = int(contents[4:5]) header_start = 4 + 16 header_end = header_start + 24 # 6l == 24 bytes assert version >= 2, "Version 1 file found: no conversion necessary" isutcnt, isstdcnt, leapcnt, timecnt, typecnt, charcnt = struct.unpack( ">6l", contents[header_start:header_end] ) file_size = ( timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + isstdcnt + isutcnt ) file_size += header_end out = b"TZif" + b"\x00" + contents[5:file_size] assert ( contents[file_size : (file_size + 4)] == b"TZif" ), "Version 2 file not truncated at Version 2 header" return out class ZoneDumpData: @classmethod def transition_keys(cls): return cls._get_zonedump().keys() @classmethod def load_transition_examples(cls, key): return cls._get_zonedump()[key] @classmethod def fixed_offset_zones(cls): if not cls._FIXED_OFFSET_ZONES: cls._populate_fixed_offsets() return cls._FIXED_OFFSET_ZONES.items() @classmethod def _get_zonedump(cls): if not cls._ZONEDUMP_DATA: cls._populate_zonedump_data() return cls._ZONEDUMP_DATA @classmethod def _populate_fixed_offsets(cls): cls._FIXED_OFFSET_ZONES = { "UTC": ZoneOffset("UTC", ZERO, ZERO), } @classmethod def _populate_zonedump_data(cls): def _Africa_Abidjan(): LMT = ZoneOffset("LMT", timedelta(seconds=-968)) GMT = ZoneOffset("GMT", ZERO) return [ ZoneTransition(datetime(1912, 1, 1), LMT, GMT), ] def _Africa_Casablanca(): P00_s = ZoneOffset("+00", ZERO, ZERO) P01_d = ZoneOffset("+01", ONE_H, ONE_H) P00_d = ZoneOffset("+00", ZERO, -ONE_H) P01_s = ZoneOffset("+01", ONE_H, ZERO) return [ # Morocco sometimes pauses DST during Ramadan ZoneTransition(datetime(2018, 3, 25, 2), P00_s, P01_d), ZoneTransition(datetime(2018, 5, 13, 3), P01_d, P00_s), ZoneTransition(datetime(2018, 6, 17, 2), P00_s, P01_d), # On October 28th Morocco set standard time to +01, # with negative DST only during Ramadan ZoneTransition(datetime(2018, 10, 28, 3), P01_d, P01_s), ZoneTransition(datetime(2019, 5, 5, 3), P01_s, P00_d), ZoneTransition(datetime(2019, 6, 9, 2), P00_d, P01_s), ] def _America_Los_Angeles(): LMT = ZoneOffset("LMT", timedelta(seconds=-28378), ZERO) PST = ZoneOffset("PST", timedelta(hours=-8), ZERO) PDT = ZoneOffset("PDT", timedelta(hours=-7), ONE_H) PWT = ZoneOffset("PWT", timedelta(hours=-7), ONE_H) PPT = ZoneOffset("PPT", timedelta(hours=-7), ONE_H) return [ ZoneTransition(datetime(1883, 11, 18, 12, 7, 2), LMT, PST), ZoneTransition(datetime(1918, 3, 31, 2), PST, PDT), ZoneTransition(datetime(1918, 3, 31, 2), PST, PDT), ZoneTransition(datetime(1918, 10, 27, 2), PDT, PST), # Transition to Pacific War Time ZoneTransition(datetime(1942, 2, 9, 2), PST, PWT), # Transition from Pacific War Time to Pacific Peace Time ZoneTransition(datetime(1945, 8, 14, 16), PWT, PPT), ZoneTransition(datetime(1945, 9, 30, 2), PPT, PST), ZoneTransition(datetime(2015, 3, 8, 2), PST, PDT), ZoneTransition(datetime(2015, 11, 1, 2), PDT, PST), # After 2038: Rules continue indefinitely ZoneTransition(datetime(2450, 3, 13, 2), PST, PDT), ZoneTransition(datetime(2450, 11, 6, 2), PDT, PST), ] def _America_Santiago(): LMT = ZoneOffset("LMT", timedelta(seconds=-16966), ZERO) SMT = ZoneOffset("SMT", timedelta(seconds=-16966), ZERO) N05 = ZoneOffset("-05", timedelta(seconds=-18000), ZERO) N04 = ZoneOffset("-04", timedelta(seconds=-14400), ZERO) N03 = ZoneOffset("-03", timedelta(seconds=-10800), ONE_H) return [ ZoneTransition(datetime(1890, 1, 1), LMT, SMT), ZoneTransition(datetime(1910, 1, 10), SMT, N05), ZoneTransition(datetime(1916, 7, 1), N05, SMT), ZoneTransition(datetime(2008, 3, 30), N03, N04), ZoneTransition(datetime(2008, 10, 12), N04, N03), ZoneTransition(datetime(2040, 4, 8), N03, N04), ZoneTransition(datetime(2040, 9, 2), N04, N03), ] def _Asia_Tokyo(): JST = ZoneOffset("JST", timedelta(seconds=32400), ZERO) JDT = ZoneOffset("JDT", timedelta(seconds=36000), ONE_H) # Japan had DST from 1948 to 1951, and it was unusual in that # the transition from DST to STD occurred at 25:00, and is # denominated as such in the time zone database return [ ZoneTransition(datetime(1948, 5, 2), JST, JDT), ZoneTransition(datetime(1948, 9, 12, 1), JDT, JST), ZoneTransition(datetime(1951, 9, 9, 1), JDT, JST), ] def _Australia_Sydney(): LMT = ZoneOffset("LMT", timedelta(seconds=36292), ZERO) AEST = ZoneOffset("AEST", timedelta(seconds=36000), ZERO) AEDT = ZoneOffset("AEDT", timedelta(seconds=39600), ONE_H) return [ ZoneTransition(datetime(1895, 2, 1), LMT, AEST), ZoneTransition(datetime(1917, 1, 1, 0, 1), AEST, AEDT), ZoneTransition(datetime(1917, 3, 25, 2), AEDT, AEST), ZoneTransition(datetime(2012, 4, 1, 3), AEDT, AEST), ZoneTransition(datetime(2012, 10, 7, 2), AEST, AEDT), ZoneTransition(datetime(2040, 4, 1, 3), AEDT, AEST), ZoneTransition(datetime(2040, 10, 7, 2), AEST, AEDT), ] def _Europe_Dublin(): LMT = ZoneOffset("LMT", timedelta(seconds=-1500), ZERO) DMT = ZoneOffset("DMT", timedelta(seconds=-1521), ZERO) IST_0 = ZoneOffset("IST", timedelta(seconds=2079), ONE_H) GMT_0 = ZoneOffset("GMT", ZERO, ZERO) BST = ZoneOffset("BST", ONE_H, ONE_H) GMT_1 = ZoneOffset("GMT", ZERO, -ONE_H) IST_1 = ZoneOffset("IST", ONE_H, ZERO) return [ ZoneTransition(datetime(1880, 8, 2, 0), LMT, DMT), ZoneTransition(datetime(1916, 5, 21, 2), DMT, IST_0), ZoneTransition(datetime(1916, 10, 1, 3), IST_0, GMT_0), ZoneTransition(datetime(1917, 4, 8, 2), GMT_0, BST), ZoneTransition(datetime(2016, 3, 27, 1), GMT_1, IST_1), ZoneTransition(datetime(2016, 10, 30, 2), IST_1, GMT_1), ZoneTransition(datetime(2487, 3, 30, 1), GMT_1, IST_1), ZoneTransition(datetime(2487, 10, 26, 2), IST_1, GMT_1), ] def _Europe_Lisbon(): WET = ZoneOffset("WET", ZERO, ZERO) WEST = ZoneOffset("WEST", ONE_H, ONE_H) CET = ZoneOffset("CET", ONE_H, ZERO) CEST = ZoneOffset("CEST", timedelta(seconds=7200), ONE_H) return [ ZoneTransition(datetime(1992, 3, 29, 1), WET, WEST), ZoneTransition(datetime(1992, 9, 27, 2), WEST, CET), ZoneTransition(datetime(1993, 3, 28, 2), CET, CEST), ZoneTransition(datetime(1993, 9, 26, 3), CEST, CET), ZoneTransition(datetime(1996, 3, 31, 2), CET, WEST), ZoneTransition(datetime(1996, 10, 27, 2), WEST, WET), ] def _Europe_London(): LMT = ZoneOffset("LMT", timedelta(seconds=-75), ZERO) GMT = ZoneOffset("GMT", ZERO, ZERO) BST = ZoneOffset("BST", ONE_H, ONE_H) return [ ZoneTransition(datetime(1847, 12, 1), LMT, GMT), ZoneTransition(datetime(2005, 3, 27, 1), GMT, BST), ZoneTransition(datetime(2005, 10, 30, 2), BST, GMT), ZoneTransition(datetime(2043, 3, 29, 1), GMT, BST), ZoneTransition(datetime(2043, 10, 25, 2), BST, GMT), ] def _Pacific_Kiritimati(): LMT = ZoneOffset("LMT", timedelta(seconds=-37760), ZERO) N1040 = ZoneOffset("-1040", timedelta(seconds=-38400), ZERO) N10 = ZoneOffset("-10", timedelta(seconds=-36000), ZERO) P14 = ZoneOffset("+14", timedelta(seconds=50400), ZERO) # This is literally every transition in Christmas Island history return [ ZoneTransition(datetime(1901, 1, 1), LMT, N1040), ZoneTransition(datetime(1979, 10, 1), N1040, N10), # They skipped December 31, 1994 ZoneTransition(datetime(1994, 12, 31), N10, P14), ] cls._ZONEDUMP_DATA = { "Africa/Abidjan": _Africa_Abidjan(), "Africa/Casablanca": _Africa_Casablanca(), "America/Los_Angeles": _America_Los_Angeles(), "America/Santiago": _America_Santiago(), "Australia/Sydney": _Australia_Sydney(), "Asia/Tokyo": _Asia_Tokyo(), "Europe/Dublin": _Europe_Dublin(), "Europe/Lisbon": _Europe_Lisbon(), "Europe/London": _Europe_London(), "Pacific/Kiritimati": _Pacific_Kiritimati(), } _ZONEDUMP_DATA = None _FIXED_OFFSET_ZONES = None if __name__ == '__main__': unittest.main()