c2257d3a86
Jellyfin(8096), OrbStack(8097) 포트 충돌으로 변경. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
359 lines
9.1 KiB
Python
359 lines
9.1 KiB
Python
try:
|
|
from backports import zoneinfo # type: ignore # noqa: PGH003
|
|
except ImportError:
|
|
import zoneinfo
|
|
from typing import Generator
|
|
|
|
import pytest
|
|
|
|
import icalendar
|
|
|
|
from . import timezone_ids
|
|
|
|
try:
|
|
import pytz
|
|
except ImportError:
|
|
pytz = None
|
|
import itertools
|
|
import sys
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
from dateutil import tz
|
|
|
|
from icalendar.cal import Calendar, Component
|
|
from icalendar.timezone import TZP
|
|
from icalendar.timezone import tzp as _tzp
|
|
|
|
HAS_PYTZ = pytz is not None
|
|
if HAS_PYTZ:
|
|
PYTZ_UTC = [
|
|
pytz.utc,
|
|
pytz.timezone("UTC"),
|
|
]
|
|
PYTZ_IN_TIMEZONE = [
|
|
lambda dt, tzname: pytz.timezone(tzname).localize(dt),
|
|
]
|
|
PYTZ_TZP = ["pytz"]
|
|
else:
|
|
PYTZ_UTC = []
|
|
PYTZ_IN_TIMEZONE = []
|
|
PYTZ_TZP = []
|
|
|
|
|
|
class DataSource:
|
|
"""A collection of parsed ICS elements (e.g calendars, timezones, events)"""
|
|
|
|
def __init__(self, data_source_folder: Path, parser):
|
|
self._parser = parser
|
|
self._data_source_folder = data_source_folder
|
|
|
|
def keys(self):
|
|
"""Return all the files that could be used."""
|
|
return [
|
|
p.stem
|
|
for p in self._data_source_folder.iterdir()
|
|
if p.suffix.lower() == ".ics"
|
|
]
|
|
|
|
def __getitem__(self, attribute):
|
|
"""Parse a file and return the result stored in the attribute."""
|
|
if attribute.endswith(".ics"):
|
|
source_file = attribute
|
|
attribute = attribute[:-4]
|
|
else:
|
|
source_file = attribute + ".ics"
|
|
source_path = self._data_source_folder / source_file
|
|
if not source_path.is_file():
|
|
raise AttributeError(f"{source_path} does not exist.")
|
|
with source_path.open("rb") as f:
|
|
raw_ics = f.read()
|
|
source = self._parser(raw_ics)
|
|
if not isinstance(source, list):
|
|
source.raw_ics = raw_ics
|
|
source.source_file = source_file
|
|
self.__dict__[attribute] = source
|
|
return source
|
|
|
|
def __contains__(self, key):
|
|
"""key in self.keys()"""
|
|
if key.endswith(".ics"):
|
|
key = key[:-4]
|
|
return key in self.keys()
|
|
|
|
def __getattr__(self, key):
|
|
return self[key]
|
|
|
|
def __repr__(self):
|
|
return repr(self.__dict__)
|
|
|
|
@property
|
|
def multiple(self):
|
|
"""Return a list of all components parsed."""
|
|
return self.__class__(
|
|
self._data_source_folder, lambda data: self._parser(data, multiple=True)
|
|
)
|
|
|
|
|
|
HERE = Path(__file__).parent
|
|
CALENDARS_FOLDER = HERE / "calendars"
|
|
TIMEZONES_FOLDER = HERE / "timezones"
|
|
EVENTS_FOLDER = HERE / "events"
|
|
ALARMS_FOLDER = HERE / "alarms"
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def calendars(tzp):
|
|
return DataSource(CALENDARS_FOLDER, icalendar.Calendar.from_ical)
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def timezones(tzp):
|
|
return DataSource(TIMEZONES_FOLDER, icalendar.Timezone.from_ical)
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def events(tzp):
|
|
return DataSource(EVENTS_FOLDER, icalendar.Event.from_ical)
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def alarms(tzp):
|
|
return DataSource(ALARMS_FOLDER, icalendar.Alarm.from_ical)
|
|
|
|
|
|
@pytest.fixture(params=PYTZ_UTC + [zoneinfo.ZoneInfo("UTC"), tz.UTC, tz.gettz("UTC")])
|
|
def utc(request, tzp):
|
|
return request.param
|
|
|
|
|
|
@pytest.fixture(
|
|
params=PYTZ_IN_TIMEZONE
|
|
+ [
|
|
lambda dt, tzname: dt.replace(tzinfo=tz.gettz(tzname)),
|
|
lambda dt, tzname: dt.replace(tzinfo=zoneinfo.ZoneInfo(tzname)),
|
|
]
|
|
)
|
|
def in_timezone(request, tzp):
|
|
return request.param
|
|
|
|
|
|
# exclude broken calendars here
|
|
ICS_FILES_EXCLUDE = (
|
|
"big_bad_calendar.ics",
|
|
"issue_104_broken_calendar.ics",
|
|
"small_bad_calendar.ics",
|
|
"multiple_calendar_components.ics",
|
|
"pr_480_summary_with_colon.ics",
|
|
"parsing_error_in_UTC_offset.ics",
|
|
"parsing_error.ics",
|
|
)
|
|
ICS_FILES = [
|
|
file.name
|
|
for file in itertools.chain(
|
|
CALENDARS_FOLDER.iterdir(), TIMEZONES_FOLDER.iterdir(), EVENTS_FOLDER.iterdir()
|
|
)
|
|
if file.name not in ICS_FILES_EXCLUDE
|
|
]
|
|
|
|
|
|
@pytest.fixture(params=ICS_FILES)
|
|
def ics_file(tzp, calendars, timezones, events, request):
|
|
"""An example ICS file."""
|
|
ics_file = request.param
|
|
print("example file:", ics_file)
|
|
for data in calendars, timezones, events:
|
|
if ics_file in data:
|
|
return data[ics_file]
|
|
raise ValueError(f"Could not find file {ics_file}.")
|
|
|
|
|
|
FUZZ_V1 = [key for key in CALENDARS_FOLDER.iterdir() if "fuzz-testcase" in str(key)]
|
|
|
|
|
|
@pytest.fixture(params=FUZZ_V1)
|
|
def fuzz_v1_calendar(request):
|
|
"""Clusterfuzz calendars."""
|
|
return request.param
|
|
|
|
|
|
@pytest.fixture
|
|
def x_sometime():
|
|
"""Map x_sometime to time"""
|
|
icalendar.cal.types_factory.types_map["X-SOMETIME"] = "time"
|
|
yield
|
|
icalendar.cal.types_factory.types_map.pop("X-SOMETIME")
|
|
|
|
|
|
@pytest.fixture
|
|
def factory():
|
|
"""Return a new component factory."""
|
|
return icalendar.ComponentFactory()
|
|
|
|
|
|
@pytest.fixture
|
|
def vUTCOffset_ignore_exceptions():
|
|
icalendar.vUTCOffset.ignore_exceptions = True
|
|
yield
|
|
icalendar.vUTCOffset.ignore_exceptions = False
|
|
|
|
|
|
@pytest.fixture
|
|
def event_component(tzp):
|
|
"""Return an event component."""
|
|
c = Component()
|
|
c.name = "VEVENT"
|
|
return c
|
|
|
|
|
|
@pytest.fixture
|
|
def c(tzp):
|
|
"""Return an empty component."""
|
|
c = Component()
|
|
return c
|
|
|
|
|
|
comp = c
|
|
|
|
|
|
@pytest.fixture
|
|
def calendar_component(tzp):
|
|
"""Return an empty component."""
|
|
c = Component()
|
|
c.name = "VCALENDAR"
|
|
return c
|
|
|
|
|
|
@pytest.fixture
|
|
def filled_event_component(c, calendar_component):
|
|
"""Return an event with some values and add it to calendar_component."""
|
|
e = Component(summary="A brief history of time")
|
|
e.name = "VEVENT"
|
|
e.add("dtend", "20000102T000000", encode=0)
|
|
e.add("dtstart", "20000101T000000", encode=0)
|
|
calendar_component.add_component(e)
|
|
return e
|
|
|
|
|
|
@pytest.fixture()
|
|
def calendar_with_resources(tzp):
|
|
c = Calendar()
|
|
c["resources"] = 'Chair, Table, "Room: 42"'
|
|
return c
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def tzp(tzp_name) -> Generator[TZP, None, None]:
|
|
"""The timezone provider."""
|
|
_tzp.use(tzp_name)
|
|
yield _tzp
|
|
_tzp.use_default()
|
|
|
|
|
|
@pytest.fixture(params=PYTZ_TZP + ["zoneinfo"])
|
|
def other_tzp(request, tzp):
|
|
"""This is annother timezone provider.
|
|
|
|
The purpose here is to cross test: pytz <-> zoneinfo.
|
|
tzp as parameter makes sure we test the cross product.
|
|
"""
|
|
return TZP(request.param)
|
|
|
|
|
|
@pytest.fixture
|
|
def pytz_only(tzp, tzp_name) -> str:
|
|
"""Skip tests that are not running under pytz."""
|
|
assert tzp.uses_pytz()
|
|
return tzp_name
|
|
|
|
|
|
@pytest.fixture
|
|
def zoneinfo_only(tzp, request, tzp_name) -> str:
|
|
"""Skip tests that are not running under zoneinfo."""
|
|
assert tzp.uses_zoneinfo()
|
|
return tzp_name
|
|
|
|
|
|
@pytest.fixture
|
|
def no_pytz(tzp_name) -> str:
|
|
"""Do not run tests with pytz."""
|
|
assert tzp_name != "pytz"
|
|
return tzp_name
|
|
|
|
|
|
@pytest.fixture
|
|
def no_zoneinfo(tzp_name) -> str:
|
|
"""Do not run tests with zoneinfo."""
|
|
assert tzp_name != "zoneinfo"
|
|
return tzp_name
|
|
|
|
|
|
def pytest_generate_tests(metafunc):
|
|
"""Parametrize without skipping:
|
|
|
|
tzp_name will be parametrized according to the use of
|
|
- pytz_only
|
|
- zoneinfo_only
|
|
- no_pytz
|
|
- no_zoneinfo
|
|
|
|
See https://docs.pytest.org/en/6.2.x/example/parametrize.html#deferring-the-setup-of-parametrized-resources
|
|
"""
|
|
if "tzp_name" in metafunc.fixturenames:
|
|
tzp_names = PYTZ_TZP + ["zoneinfo"]
|
|
if "zoneinfo_only" in metafunc.fixturenames:
|
|
tzp_names = ["zoneinfo"]
|
|
if "pytz_only" in metafunc.fixturenames:
|
|
tzp_names = PYTZ_TZP
|
|
assert not (
|
|
"zoneinfo_only" in metafunc.fixturenames
|
|
and "pytz_only" in metafunc.fixturenames
|
|
), "Use pytz_only or zoneinfo_only but not both!"
|
|
for name in ["pytz", "zoneinfo"]:
|
|
if f"no_{name}" in metafunc.fixturenames and name in tzp_names:
|
|
tzp_names.remove(name)
|
|
metafunc.parametrize("tzp_name", tzp_names, scope="module")
|
|
|
|
|
|
class DoctestZoneInfo(zoneinfo.ZoneInfo):
|
|
"""Constent ZoneInfo representation for tests."""
|
|
|
|
def __repr__(self):
|
|
return f"ZoneInfo(key={self.key!r})"
|
|
|
|
|
|
def doctest_print(obj):
|
|
"""doctest print"""
|
|
if isinstance(obj, bytes):
|
|
obj = obj.decode("UTF-8")
|
|
print(str(obj).strip().replace("\r\n", "\n").replace("\r", "\n"))
|
|
|
|
|
|
def doctest_import(name, *args, **kw):
|
|
"""Replace the import mechanism to skip the whole doctest if we import pytz."""
|
|
if name == "pytz":
|
|
return pytz
|
|
return __import__(name, *args, **kw)
|
|
|
|
|
|
@pytest.fixture
|
|
def env_for_doctest(monkeypatch):
|
|
"""Modify the environment to make doctests run."""
|
|
monkeypatch.setitem(sys.modules, "zoneinfo", zoneinfo)
|
|
monkeypatch.setattr(zoneinfo, "ZoneInfo", DoctestZoneInfo)
|
|
from icalendar.timezone.zoneinfo import ZONEINFO
|
|
uid = uuid.UUID("d755cef5-2311-46ed-a0e1-6733c9e15c63", version=4)
|
|
monkeypatch.setattr(uuid, "uuid4", lambda: uid)
|
|
|
|
monkeypatch.setattr(ZONEINFO, "utc", zoneinfo.ZoneInfo("UTC"))
|
|
return {"print": doctest_print}
|
|
|
|
|
|
@pytest.fixture(params=timezone_ids.TZIDS)
|
|
def tzid(request: pytest.FixtureRequest) -> str:
|
|
"""Return a timezone id to be used with pytz or zoneinfo.
|
|
|
|
This goes through all the different timezones possible.
|
|
"""
|
|
return request.param
|