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, 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 _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 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_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 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 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 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 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"))