def test_calendar_query_bogus_timezone_id(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
), ),
caldavxml.TimeZoneID.fromString("bogus"),
)
result = yield self.calendar_query(
query, got_xml=None, expected_code=responsecode.FORBIDDEN)
self.assertTrue("valid-timezone" in result)
def __init__(self, store, options, output, reactor, config):
super(PodMigrationService, self).__init__(store)
self.options = options
self.output = output
self.reactor = reactor
self.config = config
TimezoneCache.create()
def __init__(self, store, options, output, reactor, config):
super(PodMigrationService, self).__init__(store)
self.options = options
self.output = output
self.reactor = reactor
self.config = config
TimezoneCache.create()
def __init__(self,
records,
populator,
random,
parameters,
reactor,
servers,
principalPathTemplate,
serializationPath,
workerIndex=0,
workerCount=1):
self._records = records
self.populator = populator
self._random = random
self.reactor = reactor
self.servers = servers
self.principalPathTemplate = principalPathTemplate
self.serializationPath = serializationPath
self._pop = self.populator.populate(parameters)
self._user = 0
self._stopped = False
self.workerIndex = workerIndex
self.workerCount = workerCount
self.clients = []
TimezoneCache.create()
def test_copyPackage_Concurrency(self):
"""
Test that concurrent copying of the tz package works.
"""
self.patch(config, "UsePackageTimezones", False)
TimezoneCache.clear()
ex = [None, None]
def _try(n):
try:
TimezoneCache.create()
except:
f = Failure()
ex[n] = str(f)
t1 = threading.Thread(target=_try, args=(0, ))
t2 = threading.Thread(target=_try, args=(1, ))
t1.start()
t2.start()
t1.join()
t2.join()
self.assertTrue(ex[0] is None, msg=ex[0])
self.assertTrue(ex[1] is None, msg=ex[1])
self.assertTrue(
os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertTrue(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "America",
"New_York.ics")))
def test_copyPackage_Concurrency(self):
"""
Test that concurrent copying of the tz package works.
"""
self.patch(config, "UsePackageTimezones", False)
TimezoneCache.clear()
ex = [None, None]
def _try(n):
try:
TimezoneCache.create()
except:
f = Failure()
ex[n] = str(f)
t1 = threading.Thread(target=_try, args=(0,))
t2 = threading.Thread(target=_try, args=(1,))
t1.start()
t2.start()
t1.join()
t2.join()
self.assertTrue(ex[0] is None, msg=ex[0])
self.assertTrue(ex[1] is None, msg=ex[1])
self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "America", "New_York.ics")))
def test_calendar_query_bogus_timezone_id(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(),),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(),),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
),
),
caldavxml.TimeZoneID.fromString("bogus"),
)
result = yield self.calendar_query(query, got_xml=None, expected_code=responsecode.FORBIDDEN)
self.assertTrue("valid-timezone" in result)
def __init__(self, store, options, reactor, config):
super(ImporterService, self).__init__(store)
self.options = options
self.reactor = reactor
self.config = config
self._directory = self.store.directoryService()
TimezoneCache.create()
def __init__(self, store, options, reactor, config):
super(ImporterService, self).__init__(store)
self.options = options
self.reactor = reactor
self.config = config
self._directory = self.store.directoryService()
TimezoneCache.create()
def _calendarTimezoneUpgrade_setup(self):
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tz1 = Component(None, pycalendar=readVTZ("Etc/GMT+1"))
tz2 = Component(None, pycalendar=readVTZ("Etc/GMT+2"))
tz3 = Component(None, pycalendar=readVTZ("Etc/GMT+3"))
# Share user01 calendar with user03
calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01"))
home3 = yield self.homeUnderTest(name="user03")
shared_name = yield calendar.shareWith(home3, _BIND_MODE_WRITE)
user_details = (
("user01", "calendar_1", tz1),
("user02", "calendar_1", tz2),
("user03", "calendar_1", None),
("user03", shared_name, tz3),
)
# Set dead properties on calendars
for user, calname, tz in user_details:
calendar = (yield self.calendarUnderTest(name=calname, home=user))
if tz:
calendar.properties()[PropertyName.fromElement(caldavxml.CalendarTimeZone)] = caldavxml.CalendarTimeZone.fromString(str(tz))
# Force data version to previous
home = (yield self.homeUnderTest(name=user))
ch = home._homeSchema
yield Update(
{ch.DATAVERSION: 4},
Where=ch.RESOURCE_ID == home._resourceID,
).on(self.transactionUnderTest())
yield self.commit()
for user, calname, tz in user_details:
calendar = (yield self.calendarUnderTest(name=calname, home=user))
self.assertEqual(calendar.getTimezone(), None)
self.assertEqual(PropertyName.fromElement(caldavxml.CalendarTimeZone) in calendar.properties(), tz is not None)
yield self.commit()
# Create "fake" entry for non-existent share
txn = self.transactionUnderTest()
calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01"))
rp = schema.RESOURCE_PROPERTY
yield Insert(
{
rp.RESOURCE_ID: calendar._resourceID,
rp.NAME: PropertyName.fromElement(caldavxml.CalendarTimeZone).toString(),
rp.VALUE: caldavxml.CalendarTimeZone.fromString(str(tz3)).toxml(),
rp.VIEWER_UID: "user04",
}
).on(txn)
yield self.commit()
returnValue(user_details)
def testRead(self):
xmlfile = self.mktemp()
db1 = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db1.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
db2 = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db2.readDatabase()
self.assertEqual(db1.dtstamp, db2.dtstamp)
self.assertEqual(len(db1.timezones), len(db2.timezones))
def test_truncatedDec(self):
"""
Custom VTZ valid from 2007. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone))
def test_truncatedApr(self):
"""
Custom VTZ with truncated standard time - 2006. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone))
def testRead(self):
xmlfile = self.mktemp()
db1 = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db1.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
db2 = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db2.readDatabase()
self.assertEqual(db1.dtstamp, db2.dtstamp)
self.assertEqual(len(db1.timezones), len(db2.timezones))
def test_truncatedDec(self):
"""
Properties in components
"""
TimezoneCache.create("")
TimezoneCache.clear()
self.doTest(
"TruncatedDec10.ics",
PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True))
)
def test_truncatedApr(self):
"""
Properties in components
"""
TimezoneCache.create("")
TimezoneCache.clear()
self.doTest(
"TruncatedApr01.ics",
PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True))
)
def test_truncatedDec(self):
"""
Custom VTZ valid from 2007. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedDec10.ics",
PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True))
)
def test_truncatedApr(self):
"""
Custom VTZ with truncated standard time - 2006. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedApr01.ics",
PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True))
)
def test_truncatedAprThenDecOK(self):
"""
Properties in components
"""
oldtzid = getTzid("America/New_York")
try:
registerTzid("America/New_York", None)
tzcache = TimezoneCache()
tzcache.register()
self.doTest(
"TruncatedApr01.ics",
datetime.datetime(2007, 04, 01, 16, 0, 0, tzinfo=utc),
datetime.datetime(2007, 04, 01, 17, 0, 0, tzinfo=utc),
)
def test_copyPackage(self):
"""
Test that copying of the tz package works.
"""
self.patch(config, "UsePackageTimezones", True)
TimezoneCache.clear()
TimezoneCache.create()
self.assertFalse(
os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertFalse(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "America",
"New_York.ics")))
pkg_tz = readTZ("America/New_York")
self.patch(config, "UsePackageTimezones", False)
TimezoneCache.clear()
TimezoneCache.create()
self.assertTrue(
os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertTrue(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "America",
"New_York.ics")))
copy_tz = readTZ("America/New_York")
self.assertEqual(str(pkg_tz), str(copy_tz))
def test_truncatedDecThenApr(self):
"""
Custom VTZ valid from 2007 loaded first. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone))
self.doTest("TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone))
def test_truncatedAprThenDecOK(self):
"""
Properties in components
"""
TimezoneCache.create()
self.doTest(
"TruncatedApr01.ics",
PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)),
)
self.doTest(
"TruncatedDec10.ics",
PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)),
)
def __init__(self, records, populator, parameters, reactor, server,
principalPathTemplate, serializationPath, workerIndex=0, workerCount=1):
self._records = records
self.populator = populator
self.reactor = reactor
self.server = server
self.principalPathTemplate = principalPathTemplate
self.serializationPath = serializationPath
self._pop = self.populator.populate(parameters)
self._user = 0
self._stopped = False
self.workerIndex = workerIndex
self.workerCount = workerCount
self.clients = []
TimezoneCache.create()
def test_not_in_cache(self):
TimezoneCache.create()
data = """BEGIN:VCALENDAR
VERSION:2.0
BEGIN:VTIMEZONE
TZID:US-Eastern
LAST-MODIFIED:19870101T000000Z
BEGIN:STANDARD
DTSTART:19671029T020000
RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
TZNAME:Eastern Standard Time (US & Canada)
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:19870405T020000
RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
TZNAME:Eastern Daylight Time (US & Canada)
END:DAYLIGHT
END:VTIMEZONE
BEGIN:VEVENT
UID:12345-67890
DTSTART;TZID="US-Eastern":20071225T000000
DTEND;TZID="US-Eastern":20071225T010000
ATTENDEE:mailto:[email protected]
ATTENDEE:mailto:[email protected]
END:VEVENT
END:VCALENDAR
"""
calendar = Component.fromString(data)
if calendar.name() != "VCALENDAR":
self.fail("Calendar is not a VCALENDAR")
instances = calendar.expandTimeRanges(DateTime(2100, 1, 1))
for key in instances:
instance = instances[key]
start = instance.start
end = instance.end
self.assertEqual(
start, DateTime(2007, 12, 25, 05, 0, 0, Timezone.UTCTimezone))
self.assertEqual(
end, DateTime(2007, 12, 25, 06, 0, 0, Timezone.UTCTimezone))
break
def test_truncatedAprThenDecOK(self):
"""
VTZ loaded from std timezone DB. 2007 OK.
"""
TimezoneCache.create()
self.doTest(
"TruncatedApr01.ics",
PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)),
)
self.doTest(
"TruncatedDec10.ics",
PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)),
)
def test_truncatedAprThenDecOK(self):
"""
VTZ loaded from std timezone DB. 2007 OK.
"""
TimezoneCache.create()
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone),
)
self.doTest(
"TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone),
)
def test_truncatedAprThenDecFail(self):
"""
Custom VTZ with truncated standard time - 2006 loaded first. Daylight 2007 OK, standard 2007 wrong.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone),
)
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone),
testEqual=False)
def test_truncatedAprThenDecOK(self):
"""
VTZ loaded from std timezone DB. 2007 OK.
"""
TimezoneCache.create()
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone),
)
self.doTest(
"TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone),
DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone),
)
def test_not_in_cache(self):
TimezoneCache.create()
data = """BEGIN:VCALENDAR
VERSION:2.0
BEGIN:VTIMEZONE
TZID:US-Eastern
LAST-MODIFIED:19870101T000000Z
BEGIN:STANDARD
DTSTART:19671029T020000
RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
TZNAME:Eastern Standard Time (US & Canada)
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:19870405T020000
RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
TZNAME:Eastern Daylight Time (US & Canada)
END:DAYLIGHT
END:VTIMEZONE
BEGIN:VEVENT
UID:12345-67890
DTSTART;TZID="US-Eastern":20071225T000000
DTEND;TZID="US-Eastern":20071225T010000
ATTENDEE:mailto:[email protected]
ATTENDEE:mailto:[email protected]
END:VEVENT
END:VCALENDAR
"""
calendar = Component.fromString(data)
if calendar.name() != "VCALENDAR":
self.fail("Calendar is not a VCALENDAR")
instances = calendar.expandTimeRanges(PyCalendarDateTime(2100, 1, 1))
for key in instances:
instance = instances[key]
start = instance.start
end = instance.end
self.assertEqual(start, PyCalendarDateTime(2007, 12, 25, 05, 0, 0, PyCalendarTimezone(utc=True)))
self.assertEqual(end, PyCalendarDateTime(2007, 12, 25, 06, 0, 0, PyCalendarTimezone(utc=True)))
break
def testListChangedSince(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tzids = set([tz.tzid for tz in db.listTimezones(db.dtstamp)])
self.assertTrue(len(tzids) == 0)
def testCreate(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
self.assertTrue(db.dtstamp is not None)
self.assertTrue(len(db.timezones) > 0)
def test_truncatedDecThenApr(self):
"""
Custom VTZ valid from 2007 loaded first. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone(utc=True)),
DateTime(2007, 12, 10, 18, 0, 0, Timezone(utc=True))
)
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone(utc=True)),
DateTime(2007, 04, 01, 17, 0, 0, Timezone(utc=True))
)
def _initPrimaryService(self):
tzpath = TimezoneCache.getDBPath()
xmlfile = os.path.join(tzpath, "timezones.xml")
self.timezones = PrimaryTimezoneDatabase(tzpath, xmlfile)
if not os.path.exists(xmlfile):
self.timezones.createNewDatabase()
else:
self.timezones.readDatabase()
self.info_source = TimezoneCache.version
def testCreate(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
self.assertTrue(db.dtstamp is not None)
self.assertTrue(len(db.timezones) > 0)
def testListChangedSince(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tzids = set([tz.tzid for tz in db.listTimezones(db.dtstamp)])
self.assertTrue(len(tzids) == 0)
def testGetNone(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tz = db.getTimezone("Bogus")
self.assertEqual(tz, None)
def testGetNone(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tz = db.getTimezone("Bogus")
self.assertEqual(tz, None)
def _initPrimaryService(self):
tzpath = TimezoneCache.getDBPath()
xmlfile = os.path.join(tzpath, "timezones.xml")
self.timezones = PrimaryTimezoneDatabase(tzpath, xmlfile)
if not os.path.exists(xmlfile):
self.timezones.createNewDatabase()
else:
self.timezones.readDatabase()
self.info_source = TimezoneCache.version
def testList(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tzids = set([tz.tzid for tz in db.listTimezones(None)])
self.assertTrue("America/New_York" in tzids)
self.assertTrue("US/Eastern" not in tzids)
def test_truncatedAprThenDecFail(self):
"""
Custom VTZ with truncated standard time - 2006 loaded first. Daylight 2007 OK, standard 2007 wrong.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedApr01.ics",
PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)),
)
self.doTest(
"TruncatedDec10.ics",
PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)),
PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)),
testEqual=False
)
def testList(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
tzids = set([tz.tzid for tz in db.listTimezones(None)])
self.assertTrue("America/New_York" in tzids)
self.assertTrue("US/Eastern" not in tzids)
def testUpdate(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
db.updateDatabase()
self.assertTrue(db.changeCount == 0)
self.assertTrue(len(db.changed) == 0)
def testUpdate(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
db.updateDatabase()
self.assertTrue(db.changeCount == 0)
self.assertTrue(len(db.changed) == 0)
def test_calendar_query_timezone(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tzid1 = "Etc/GMT+1"
tz1 = Component(None, pycalendar=readVTZ(tzid1))
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
), ),
caldavxml.TimeZone.fromCalendar(tz1),
)
def got_xml(doc):
if not isinstance(doc.root_element, davxml.MultiStatus):
self.fail(
"REPORT response XML root element is not multistatus: %r" %
(doc.root_element, ))
return self.calendar_query(query, got_xml)
def test_basic(self):
registerTzid("America/New_York", None)
registerTzid("US/Eastern", None)
tzcache = TimezoneCache()
tzcache.register()
self.assertTrue(tzcache.loadTimezone("America/New_York"))
self.assertTrue(tzcache.loadTimezone("US/Eastern"))
tzcache.unregister()
def test_calendar_query_timezone(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tzid1 = "Etc/GMT+1"
tz1 = Component(None, pycalendar=readVTZ(tzid1))
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(),),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(),),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
),
),
caldavxml.TimeZone.fromCalendar(tz1),
)
def got_xml(doc):
if not isinstance(doc.root_element, davxml.MultiStatus):
self.fail("REPORT response XML root element is not multistatus: %r" % (doc.root_element,))
return self.calendar_query(query, got_xml)
def test_calendar_query_wrong_timezone_elements(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tzid1 = "Etc/GMT+1"
tz1 = Component(None, pycalendar=readVTZ(tzid1))
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(),),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(),),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
),
),
caldavxml.TimeZone.fromCalendar(tz1),
)
query.children += (caldavxml.TimeZoneID.fromString(tzid1),)
result = yield self.calendar_query(query, got_xml=None, expected_code=responsecode.BAD_REQUEST)
self.assertTrue("Only one of" in result)
def test_calendar_query_wrong_timezone_elements(self):
"""
Partial retrieval of events by time range.
(CalDAV-access-09, section 7.6.1)
"""
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tzid1 = "Etc/GMT+1"
tz1 = Component(None, pycalendar=readVTZ(tzid1))
calendar_properties = (
davxml.GETETag(),
caldavxml.CalendarData(),
)
query_timerange = caldavxml.TimeRange(
start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ),
end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ),
)
query = caldavxml.CalendarQuery(
davxml.PropertyContainer(*calendar_properties),
caldavxml.Filter(
caldavxml.ComponentFilter(
caldavxml.ComponentFilter(
query_timerange,
name="VEVENT",
),
name="VCALENDAR",
), ),
caldavxml.TimeZone.fromCalendar(tz1),
)
query.children += (caldavxml.TimeZoneID.fromString(tzid1), )
result = yield self.calendar_query(
query, got_xml=None, expected_code=responsecode.BAD_REQUEST)
self.assertTrue("Only one of" in result)
def _initSecondaryService(self):
# Must have writeable paths
tzpath = TimezoneCache.getDBPath()
xmlfile = config.TimezoneService.XMLInfoPath
if not xmlfile:
xmlfile = os.path.join(tzpath, "timezones.xml")
self.timezones = SecondaryTimezoneDatabase(tzpath, xmlfile, None)
try:
self.timezones.readDatabase()
except:
pass
self.info_source = "Secondary"
self.primary = False
def _initSecondaryService(self):
# Must have writeable paths
tzpath = TimezoneCache.getDBPath()
xmlfile = config.TimezoneService.XMLInfoPath
if not xmlfile:
xmlfile = os.path.join(tzpath, "timezones.xml")
self.timezones = SecondaryTimezoneDatabase(tzpath, xmlfile, None)
try:
self.timezones.readDatabase()
except:
pass
self.info_source = "Secondary"
self.primary = False
def testGetOne(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
# Original
tz1 = db.getTimezone("America/New_York")
self.assertTrue(str(tz1).find("VTIMEZONE") != -1)
self.assertTrue(str(tz1).find("TZID:America/New_York") != -1)
# Alias
tz1 = db.getTimezone("US/Eastern")
self.assertTrue(str(tz1).find("VTIMEZONE") != -1)
self.assertTrue(str(tz1).find("TZID:US/Eastern") != -1)
def testGetOne(self):
xmlfile = self.mktemp()
db = PrimaryTimezoneDatabase(TimezoneCache.getDBPath(), xmlfile)
db.createNewDatabase()
self.assertTrue(os.path.exists(xmlfile))
# Original
tz1 = db.getTimezone("America/New_York")
self.assertTrue(str(tz1).find("VTIMEZONE") != -1)
self.assertTrue(str(tz1).find("TZID:America/New_York") != -1)
# Alias
tz1 = db.getTimezone("US/Eastern")
self.assertTrue(str(tz1).find("VTIMEZONE") != -1)
self.assertTrue(str(tz1).find("TZID:US/Eastern") != -1)
def test_copyPackage_missingVersion(self):
"""
Test that tz data is updated if the version is missing.
"""
self.patch(config, "UsePackageTimezones", False)
TimezoneCache.clear()
TimezoneCache.create()
self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
os.remove(os.path.join(config.DataRoot, "zoneinfo", "version.txt"))
self.assertFalse(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
TimezoneCache.create()
self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
def test_copyPackage_missingVersion(self):
"""
Test that tz data is updated if the version is missing.
"""
self.patch(config, "UsePackageTimezones", False)
TimezoneCache.clear()
TimezoneCache.create()
self.assertTrue(
os.path.exists(os.path.join(config.DataRoot, "zoneinfo")))
self.assertTrue(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
os.remove(os.path.join(config.DataRoot, "zoneinfo", "version.txt"))
self.assertFalse(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
TimezoneCache.create()
self.assertTrue(
os.path.exists(
os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
def _calendarTimezoneUpgrade_setup(self):
TimezoneCache.create()
self.addCleanup(TimezoneCache.clear)
tz1 = Component(None, pycalendar=readVTZ("Etc/GMT+1"))
tz2 = Component(None, pycalendar=readVTZ("Etc/GMT+2"))
tz3 = Component(None, pycalendar=readVTZ("Etc/GMT+3"))
# Share user01 calendar with user03
calendar = (yield self.calendarUnderTest(name="calendar_1",
home="user01"))
home3 = yield self.homeUnderTest(name="user03")
shared_name = yield calendar.shareWith(home3, _BIND_MODE_WRITE)
user_details = (
("user01", "calendar_1", tz1),
("user02", "calendar_1", tz2),
("user03", "calendar_1", None),
("user03", shared_name, tz3),
)
# Set dead properties on calendars
for user, calname, tz in user_details:
calendar = (yield self.calendarUnderTest(name=calname, home=user))
if tz:
calendar.properties()[PropertyName.fromElement(
caldavxml.CalendarTimeZone
)] = caldavxml.CalendarTimeZone.fromString(str(tz))
# Force data version to previous
home = (yield self.homeUnderTest(name=user))
ch = home._homeSchema
yield Update(
{
ch.DATAVERSION: 4
},
Where=ch.RESOURCE_ID == home._resourceID,
).on(self.transactionUnderTest())
yield self.commit()
for user, calname, tz in user_details:
calendar = (yield self.calendarUnderTest(name=calname, home=user))
self.assertEqual(calendar.getTimezone(), None)
self.assertEqual(
PropertyName.fromElement(caldavxml.CalendarTimeZone)
in calendar.properties(), tz is not None)
yield self.commit()
# Create "fake" entry for non-existent share
txn = self.transactionUnderTest()
calendar = (yield self.calendarUnderTest(name="calendar_1",
home="user01"))
rp = schema.RESOURCE_PROPERTY
yield Insert({
rp.RESOURCE_ID:
calendar._resourceID,
rp.NAME:
PropertyName.fromElement(caldavxml.CalendarTimeZone).toString(),
rp.VALUE:
caldavxml.CalendarTimeZone.fromString(str(tz3)).toxml(),
rp.VIEWER_UID:
"user04",
}).on(txn)
yield self.commit()
returnValue(user_details)
def tearDown(self):
TimezoneCache.clear()
TimezoneCache.create()
def _try(n):
try:
TimezoneCache.create()
except:
f = Failure()
ex[n] = str(f)
def setUp(self):
super(TimezonePackageTest, self).setUp()
TimezoneCache.clear()
TimezoneCache.create()
def test_getTZExtrasPath(self):
"""
Make sure TimezoneCache._getTZExtrasPath returns a valid file.
"""
extras = TimezoneCache._getTZExtrasPath()
self.assertTrue(os.path.isfile(extras))
def test_basic(self):
TimezoneCache.create()
self.assertTrue(readTZ("America/New_York"))
self.assertTrue(readTZ("US/Eastern"))
