def ItemsToVobject(self): """Tests itemsToVObject, which converts Chandler items to vobject.""" event = Calendar.CalendarEvent(view = self.repo.view) event.displayName = "test" event.startTime = datetime.datetime(2010, 1, 1, 10) event.endTime = datetime.datetime(2010, 1, 1, 11) cal = ICalendar.itemsToVObject(self.repo.view, [event]) self.assert_(cal.vevent[0].summary[0].value == "test", "summary not set properly, summary is %s" % cal.vevent[0].summary[0].value) start = event.startTime.replace(tzinfo=ICalendar.localtime) self.assert_(cal.vevent[0].dtstart[0].value == start, "dtstart not set properly, dtstart is %s" % cal.vevent[0].summary[0].value) event = Calendar.CalendarEvent(view = self.repo.view) event.displayName = "test2" event.startTime = datetime.datetime(2010, 1, 1) event.allDay = True cal = ICalendar.itemsToVObject(self.repo.view, [event]) self.assert_(cal.vevent[0].dtstart[0].value == datetime.date(2010,1,1), "dtstart for allDay event not set properly, dtstart is %s" % cal.vevent[0].summary[0].value)
def testICSSerializer(self): """Tests serialization of items to icalendar streams.""" event = Calendar.CalendarEvent(itsView=self.view) event.anyTime = False event.summary = uw("test") event.startTime = datetime.datetime(2010, 1, 1, 10, tzinfo=self.view.tzinfo.default) event.endTime = datetime.datetime(2010, 1, 1, 11, tzinfo=self.view.tzinfo.default) cal = getVObjectData(self.view, [event.itsItem]) self.failUnlessEqual( cal.vevent.summary.value, uw("test"), u"summary not set properly, summary is %s" % cal.vevent.summary.value) start = event.startTime self.assert_( cal.vevent.dtstart.value == start, "dtstart not set properly, dtstart is %s" % cal.vevent.summary.value) event = Calendar.CalendarEvent(itsView=self.view) event.summary = uw("test2") event.startTime = datetime.datetime(2010, 1, 1, tzinfo=self.view.tzinfo.floating) event.allDay = True event.duration = datetime.timedelta(1) self.assertEqual(event.effectiveEndTime - event.effectiveStartTime, datetime.timedelta(2)) cal = getVObjectData(self.view, [event.itsItem]) self.assert_( cal.vevent.dtstart.value == datetime.date(2010, 1, 1), u"dtstart for allDay event not set properly, dtstart is %s" % cal.vevent.summary.value) # test bug 9137, multi-day all-day events with # duration modulo 1 day == 0 are serialized as 1 day instead of 2 self.assertEqual(cal.vevent.duration.value, datetime.timedelta(2))
def _createEvent(self, startTime): event = Calendar.CalendarEvent(None, itsView=self.view) event.startTime = startTime event.endTime = event.startTime + timedelta(hours=1) event.anyTime = False event.summary = uw("Sample event") return event
def testAllDay(self): event = Calendar.CalendarEvent(itsParent=self.sandbox, anyTime=False, allDay=True) self.failUnlessEqual(event.effectiveStartTime.timetz(), self.floatingMidnight) self.failUnlessEqual(event.effectiveStartTime.date(), event.startTime.date()) self.failUnlessEqual(event.effectiveEndTime, event.effectiveStartTime + timedelta(days=1)) event.anyTime = True self.failUnlessEqual(event.effectiveStartTime.timetz(), self.floatingMidnight) self.failUnlessEqual(event.effectiveStartTime.date(), event.startTime.date()) self.failUnlessEqual(event.effectiveEndTime, event.effectiveStartTime + timedelta(days=1)) event.anyTime = event.allDay = False self.failUnlessEqual(event.startTime, event.effectiveStartTime) self.failUnlessEqual(event.effectiveStartTime.date(), event.startTime.date()) self.failUnlessEqual(event.effectiveEndTime, event.effectiveStartTime + event.duration)
def testDefaultSettings(self): defaultTz = TimeZoneInfo.get(self.sandbox.itsView).default ROUND = 30 # A new event, by default, has its startTime set to the current time # rounded to a 30-minute boundary start = datetime.now(defaultTz) event = Calendar.CalendarEvent(itsParent=self.sandbox, anyTime=False, allDay=False) end = datetime.now(defaultTz) # Check that it falls within 30 minutes of now self.failUnless(start - timedelta(minutes=ROUND) <= event.startTime and event.startTime <= end + timedelta(minutes=ROUND)) # Check that the correct rounding occurred self.failUnlessEqual(event.startTime.second, 0) self.failUnlessEqual(event.startTime.microsecond, 0) self.failUnlessEqual(event.startTime.minute % ROUND, 0) # Make sure it's in the right timezone self.failUnlessEqual(event.startTime.tzinfo, defaultTz) # Lastly, check the dates if possible if start.date() == end.date(): self.failUnlessEqual(start.date(), event.startTime.date()) self.failUnlessEqual(event.effectiveStartTime, event.startTime) self.failUnlessEqual(event.effectiveEndTime, event.endTime)
def testMultidayEdgeCase(self): tzinfo = self.sandbox.itsView.tzinfo event = Calendar.CalendarEvent( itsParent=self.sandbox, allDay=True, anyTime=False, startTime=datetime(2007, 7, 20, tzinfo=tzinfo.floating), duration=timedelta(days=0), ) self.failUnlessEqual(event.effectiveStartTime, datetime(2007, 7, 20, tzinfo=tzinfo.floating)) self.failUnlessEqual(event.effectiveEndTime, datetime(2007, 7, 21, tzinfo=tzinfo.floating)) event.duration = timedelta(days=1) # Really, the following should be 2007/07/21. However, for a while # Chandler has treated an all-day event with duration of exactly # one day as lasting two days. Jeffrey pointed out that there is # import/export code we would need to change in addition to the # domain model here. [grant 2007/10/17] self.failUnlessEqual(event.effectiveEndTime, datetime(2007, 7, 22, tzinfo=tzinfo.floating)) event.duration = timedelta(days=2, hours=3) self.failUnlessEqual(event.effectiveEndTime, datetime(2007, 7, 23, tzinfo=tzinfo.floating))
def setUp(self): if not hasattr(RecurrenceConflictTestCase, 'view'): super(RecurrenceConflictTestCase, self).setUp() RecurrenceConflictTestCase.view = self.view del self.view view = RecurrenceConflictTestCase.view self.sandbox = Item("sandbox", view, None) self.pacific = self.view.tzinfo.getInstance("America/Los_Angeles") self.floating = self.view.tzinfo.floating self.utc = self.view.tzinfo.UTC self.start = datetime.datetime(2007, 4, 10, 9, tzinfo=self.floating) self.master = Calendar.CalendarEvent(None, itsParent=self.sandbox) self.uuid = self.master.itsItem.itsUUID.str16() self.master.startTime = self.start self.master.anyTime = self.master.allDay = False # create a baseline dictionary with keywords for creating an EventRecord names = (i.name for i in EventRecord.__fields__ if i.name != 'uuid') # default values to NoChange self.kwds = dict.fromkeys(names, sharing.NoChange)
def testAtTime(self): event = Calendar.CalendarEvent(itsParent=self.sandbox, anyTime=False, allDay=False, duration=timedelta(0)) self.failUnlessEqual(event.effectiveStartTime, event.startTime) self.failUnlessEqual(event.endTime, event.startTime) self.failUnlessEqual(event.effectiveEndTime, event.startTime)
def testExportRecurrence(self): eastern = self.view.tzinfo.getInstance("America/New_York") start = datetime.datetime(2005, 2, 1, tzinfo=eastern) vevent = vobject.icalendar.RecurringComponent(name='VEVENT') vevent.behavior = vobject.icalendar.VEvent vevent.add('dtstart').value = start ruleSetItem = self._makeRecurrenceRuleSet() vevent.rruleset = ruleSetItem.createDateUtilFromRule(start) self.assertEqual(vevent.rrule.value, 'FREQ=DAILY') event = Calendar.CalendarEvent(itsView=self.view) event.anyTime = False event.summary = uw("blah") event.startTime = start event.endTime = datetime.datetime(2005, 2, 1, 1, tzinfo=eastern) event.rruleset = self._makeRecurrenceRuleSet( datetime.datetime(2005, 3, 1, tzinfo=eastern), freq='weekly', byweekday=[ WeekdayAndPositionStruct(i, 0) for i in "tuesday", "thursday" ]) vcalendar = getVObjectData(self.view, [event.itsItem]) self.assertEqual(vcalendar.vevent.dtstart.serialize(), 'DTSTART;TZID=America/New_York:20050201T000000\r\n') vcalendar.vevent = vcalendar.vevent.transformFromNative() self.assertEqual( vcalendar.vevent.rrule.serialize(), 'RRULE:FREQ=WEEKLY;BYDAY=TU,TH;UNTIL=20050302T045900Z\r\n') # move the second occurrence one day later nextEvent = event.getFirstOccurrence().getNextOccurrence() nextEvent.changeThis( pim.EventStamp.startTime.name, datetime.datetime(2005, 2, 9, tzinfo=self.view.tzinfo.floating)) nextEvent.getNextOccurrence().deleteThis() vcalendar = getVObjectData(self.view, [event.itsItem, nextEvent]) for ev in vcalendar.vevent_list: if hasattr(ev, 'recurrence_id'): modified = ev else: master = ev self.assertEqual(modified.dtstart.serialize(), 'DTSTART:20050209T000000\r\n') self.assertEqual( modified.recurrence_id.serialize(), 'RECURRENCE-ID;TZID=America/New_York:20050203T000000\r\n') self.assertEqual(master.exdate.serialize(), 'EXDATE;TZID=America/New_York:20050210T000000\r\n') vcalendar.behavior.generateImplicitParameters(vcalendar) self.assertEqual(vcalendar.vtimezone.tzid.value, "America/New_York")
def testTimeFields(self): """ Test time related fields and methods """ self.loadParcel("parcel:osaf.pim.calendar") # Test getDuration view = self.rep.view firstItem = Calendar.CalendarEvent(view=view) firstItem.anyTime = False firstItem.startTime = datetime(2003, 2, 1, 10) firstItem.endTime = datetime(2003, 2, 1, 11, 30) self.assertEqual(firstItem.duration, timedelta(hours=1.5)) # Test setDuration secondItem = Calendar.CalendarEvent(view=view) secondItem.anyTime = False secondItem.startTime = datetime(2003, 3, 5, 9) secondItem.duration = timedelta(hours=1.5) self.assertEqual(secondItem.endTime, datetime(2003, 3, 5, 10, 30)) # Test changeStartTime firstItem.ChangeStart(datetime(2003, 3, 4, 12, 45)) self.assertEqual(firstItem.duration, timedelta(hours=1.5)) self.assertEqual(firstItem.startTime, datetime(2003, 3, 4, 12, 45)) # Test reminderTime firstItem.SetReminderDelta(timedelta(minutes=-30)) self.assertEqual(firstItem.reminderTime, datetime(2003, 3, 4, 12, 15)) firstItem.SetReminderDelta(None) self.failIf(firstItem.hasLocalAttributeValue('reminderTime')) # Test allDay firstItem.allDay = True self.assertEqual(firstItem.allDay, True) firstItem.allDay = False self.assertEqual(firstItem.allDay, False) # Test anyTime firstItem.anyTime = True self.assertEqual(firstItem.anyTime, True) firstItem.anyTime = False self.assertEqual(firstItem.anyTime, False)
def testCreate(self): eventCreateDict = { 'itsView': self.view, 'summary': u'event creation test', Note.icalUID.name: u'abcdef', 'startTime': datetime.datetime(1996, 11, 11) } event = Calendar.CalendarEvent(**eventCreateDict) self.failUnlessEqual(u'abcdef', event.itsItem.icalUID)
def __init__(self, view, type, logger): if not type in ["Event", "Note", "Task", "MailMessage", "Collection"]: return else: self.isNote = self.isEvent = self.isTask = self.isMessage = self.allDay = False self.logger = logger now = datetime.now() if type == "Event": # New Calendar Event # set up the expected data dictionary with the default values self.expected_field_dict = {"displayName" : "New Event", "startTime" : now, "endTime" : now, "duration" : timedelta(minutes=60)} # create a default Calendar Event item = Calendar.CalendarEvent(view=view) item.startTime = self.expected_field_dict["startTime"] # because startTime is needed befor duration self.isEvent = True elif type == "Note": # New Note # set up the expected data dictionary with the default values self.expected_field_dict = {"displayName" : "New Note", "createdOn" : now} # create a default Note item = pim.Note(view=view) self.isNote = True elif type == "Task": # New Task # set up the expected data dictionary with the default values self.expected_field_dict = {"displayName" : "New Task", "createdOn" : now} # create a default Task item = pim.Task(view=view) self.isTask = True elif type == "MailMessage": # New Mail Message # set up the expected data dictionary with the default values email = Mail.EmailAddress(view=view) email.emailAddress = 'me' self.expected_field_dict = {"subject" : "untitled", "dateSent" : now, "fromAddress" : email} # create a default Message item = Mail.MailMessage(view=view) self.isMessage = True elif type == "Collection": # New Collection # set up the expected data dictionary with the default values self.expected_field_dict = {"displayName" : "Untitled"} # create a default Collection item = pim.ItemCollection(view=view) # fields affectation for field in self.expected_field_dict.keys(): setattr(item, field, self.expected_field_dict[field]) self.item = item if type =="Collection": Sgf.SidebarAdd(self.item) Sgf.SidebarSelect(self.item) else: Sgf.SummaryViewSelect(self.item)
def testUpdate(self): uid = u'on-a-limo-to-milano-solo-gigolos-dont-nod' task = pim.Task(itsView=self.view) task.itsItem.icalUID = uid event = Calendar.CalendarEvent(itsView=self.view, startTime=datetime.datetime(2000, 1, 1)) event.itsItem.icalUID = uid del task.itsItem.icalUID # Necessary? self.failUnless(event.itsItem is sharing.findUID(self.view, uid))
def testDeleteItem(self): """ Test calendar event deletion """ view = self.sandbox.itsView event = Calendar.CalendarEvent(itsParent=self.sandbox) item = event.itsItem path = item.itsPath item.delete() del item self.sandbox.itsView.commit() itemShouldBeGone = view.find(path) self.assertEqual(itemShouldBeGone, None)
def testDayBoundary(self): tzinfo = self.sandbox.itsView.tzinfo event = Calendar.CalendarEvent( itsParent=self.sandbox, allDay=True, anyTime=False, startTime=datetime(2007, 10, 16, 23, 30, tzinfo=tzinfo.default), duration=timedelta(hours=1), ) self.failUnlessEqual(event.effectiveStartTime, datetime(2007, 10, 16, tzinfo=tzinfo.floating)) self.failUnlessEqual(event.effectiveEndTime, datetime(2007, 10, 17, tzinfo=tzinfo.floating))
def testDeleteItem(self): """ Test calendar event deletion """ self.loadParcel("parcel:osaf.pim.calendar") view = self.rep.view item = Calendar.CalendarEvent(view=view) path = item.itsPath item.delete() del item itemShouldBeGone = view.find(path) self.assertEqual(itemShouldBeGone, None) view.commit()
def GenerateCalendarEvent(view, days=30, tzinfo=None): if tzinfo is None: tzinfo = view.tzinfo.floating event = Calendar.CalendarEvent(itsView=view) event.summary = random.choice(HEADLINES) if TEST_I18N: event.summary = uw(event.summary) # Choose random days, hours startDelta = timedelta(days=random.randint(0, days), hours=random.randint(0, 24)) now = datetime.now(tzinfo) closeToNow = datetime(now.year, now.month, now.day, now.hour, int(now.minute / 30) * 30, tzinfo=now.tzinfo) event.startTime = closeToNow + startDelta # Events are anyTime by default. Give a 5% chance of allDay instead, # or 90% of a normal event. r = random.randint(0, 100) if r < 95: # 5% chance that we'll leave anyTime on event.anyTime = False if r < 5: # 5% chance of allDay event.allDay = True # Choose random minutes event.duration = timedelta(minutes=random.choice(DURATIONS)) # Maybe a nice reminder? reminderInterval = random.choice(REMINDERS) if reminderInterval is not None: event.userReminderInterval = timedelta(minutes=-reminderInterval) # Add a location to 2/3 of the events if random.randrange(3) > 0: if TEST_I18N: event.location = Calendar.Location.getLocation( view, uw(random.choice(LOCATIONS))) else: event.location = Calendar.Location.getLocation( view, random.choice(LOCATIONS)) event.itsItem.importance = random.choice(pim.ImportanceEnum.values) event.itsItem.setTriageStatus(randomEnum(pim.TriageEnum)) return event.itsItem
def testTimeFields(self): """ Test time related fields and methods """ # Test getting duration, setting endTime defaultTz = self.sandbox.itsView.tzinfo.default firstEvent = Calendar.CalendarEvent(itsParent=self.sandbox) firstEvent.anyTime = False firstEvent.startTime = datetime(2003, 2, 1, 10, tzinfo=defaultTz) firstEvent.endTime = datetime(2003, 2, 1, 11, 30, tzinfo=defaultTz) self.assertEqual(firstEvent.duration, timedelta(hours=1.5)) # Test setting duration and getting endTime secondEvent = Calendar.CalendarEvent(itsParent=self.sandbox) secondEvent.anyTime = False secondEvent.startTime = datetime(2003, 3, 5, 9, tzinfo=defaultTz) secondEvent.duration = timedelta(hours=1.5) self.assertEqual(secondEvent.endTime, datetime(2003, 3, 5, 10, 30, tzinfo=defaultTz)) # Test changing startTime (shouldn't change duration) firstEvent.startTime = datetime(2003, 3, 4, 12, 45, tzinfo=defaultTz) self.assertEqual(firstEvent.duration, timedelta(hours=1.5)) self.assertEqual(firstEvent.startTime, datetime(2003, 3, 4, 12, 45, tzinfo=defaultTz)) # Test allDay firstEvent.allDay = True self.assertEqual(firstEvent.allDay, True) firstEvent.allDay = False self.assertEqual(firstEvent.allDay, False) # Test anyTime firstEvent.anyTime = True self.assertEqual(firstEvent.anyTime, True) firstEvent.anyTime = False self.assertEqual(firstEvent.anyTime, False)
def testTimed(self): event = Calendar.CalendarEvent( itsParent=self.sandbox, anyTime=False, allDay=False, startTime=datetime(2006, 11, 4, 13, 25, tzinfo=self.sandbox.itsView.tzinfo.default), duration=timedelta(hours=1)) self.failUnlessEqual(event.effectiveStartTime, event.startTime) self.failUnlessEqual(event.endTime - timedelta(hours=1), event.startTime) self.failUnlessEqual(event.effectiveEndTime, event.endTime)
def testFindEventUID(self): uid = u'123' self.failUnless(sharing.findUID(self.view, uid) is None) event = Calendar.CalendarEvent(itsView=self.view, displayName=u"event test", startTime=datetime.datetime( 2010, 1, 1, 10), duration=datetime.timedelta(hours=2)) self.failUnless(sharing.findUID(self.view, uid) is None) item = event.itsItem setattr(item, Note.icalUID.name, uid) self.failUnless(sharing.findUID(self.view, uid) is item)
def setUp(self): super(RecurringEventTest, self).setUp() self.start = datetime(2005, 7, 4, 13) #1PM, July 4, 2005 self.weekly = { 'end': datetime(2005, 11, 14, 13), 'start': self.start, 'count': 20 } self.monthly = { 'end': datetime(2005, 11, 4, 13), 'start': self.start, 'count': 5 } self.event = Calendar.CalendarEvent(None, view=self.rep.view) self.event.startTime = self.start self.event.endTime = self.event.startTime + timedelta(hours=1) self.event.anyTime = False self.event.displayName = "Sample event"
def testCalendarEvent(self): from i18n import ChandlerMessageFactory event = Calendar.CalendarEvent(itsParent=self.sandbox, ) # Call InitOutgoingAttributes() on the created event, the # hook for item/stamp creation in the Chandler UI. item = event.itsItem event.InitOutgoingAttributes() newEventTitle = ChandlerMessageFactory(u"New Event") self.failUnless(stamping.has_stamp(event, Calendar.EventStamp)) self.failUnlessEqual(item.displayName, newEventTitle) newNote = type(item)(itsParent=self.sandbox) newNote.InitOutgoingAttributes() # Should be _(u"Untitled") # Make sure the new event title gets reset on unstamp event.remove() self.failUnlessEqual(item.displayName, newNote.displayName)
def _populateCollection(self, repo): sandbox = repo.findPath("//sandbox") coll = sandbox.findPath("testcollection") names = [ ("Morgen", "Sagen", "*****@*****.**"), ("Ted", "Leung", "*****@*****.**"), ("Andi", "Vajda", "*****@*****.**"), ] contacts = [] for name in names: c = Contact(parent=sandbox) c.contactName = ContactName(parent=sandbox) c.contactName.firstName = name[0] c.contactName.lastName = name[1] c.emailAddress = name[2] c.displayName = "%s %s" % (name[0], name[1]) contacts.append(c) coll.displayName = "test collection" events = [ "breakfast", "lunch", "dinner", "meeting", "movie", "game", ] for i in xrange(6): c = Calendar.CalendarEvent(parent=sandbox) c.displayName = events[i % 6] c.organizer = contacts[0] c.participants = [contacts[1], contacts[2]] c.issues = ["123", "abc", "xyz"] coll.add(c)
def process_create(view, subcommand, text): if subcommand == 'note': note = pim.Note(itsView=view, displayName=text) view.commit() elif subcommand == 'event': first_space = text.find(' ') s = text[:first_space] second_space = text.find(' ', first_space + 1) l = text[first_space + 1:second_space] data = text[second_space + 1:] start = parse_datetime(s) length = parse_timedelta(l) task = Calendar.CalendarEvent(itsView=view, startTime=start, duration=length) view.commit() elif subcommand == 'task': task = pim.Task(itsView=view, displayName=text) view.commit() else: print "illegal create subcomand"
def writeICalendarUnicodeBug3338(self): event = Calendar.CalendarEvent(view = self.repo.view) event.displayName = u"unicode \u0633\u0644\u0627\u0645" event.startTime = datetime.datetime(2010, 1, 1, 10) event.endTime = datetime.datetime(2010, 1, 1, 11) coll = ItemCollection(name="testcollection", parent=self.sandbox) coll.add(event) filename = "unicode_export.ics" conduit = Sharing.FileSystemConduit(name="conduit", sharePath=".", shareName=filename, view=self.repo.view) format = ICalendar.ICalendarFormat(name="format", view=self.repo.view) self.share = Sharing.Share(name="share",contents=coll, conduit=conduit, format=format, view=self.repo.view) if self.share.exists(): self.share.destroy() self.share.create() self.share.put() cal=vobject.readComponents(file(filename, 'rb')).next() self.assertEqual(cal.vevent[0].summary[0].value, event.displayName) self.share.destroy()
def GenerateCalendarEvent(view, days=30): event = Calendar.CalendarEvent(view=view) event.displayName = random.choice(HEADLINES) # Choose random days, hours startDelta = timedelta(days=random.randint(0, days), hours=random.randint(0, 24)) now = datetime.now() closeToNow = datetime(now.year, now.month, now.day, now.hour, int(now.minute / 30) * 30) event.startTime = closeToNow + startDelta # Events are anyTime by default. Give a 5% chance of allDay instead, # or 90% of a normal event. r = random.randint(0, 100) if r < 95: # 5% chance that we'll turn anyTime off event.anyTime = False if r < 5: # 5% chance of allDay event.allDay = True # Choose random minutes event.duration = timedelta(minutes=random.choice(DURATIONS)) # Maybe a nice reminder? reminderInterval = random.choice(REMINDERS) if reminderInterval is not None: event.reminderTime = event.startTime - timedelta( minutes=reminderInterval) # Add a location to 2/3 of the events if random.randrange(3) > 0: event.location = Calendar.Location.getLocation( view, random.choice(LOCATIONS)) event.importance = random.choice(IMPORTANCE) return event
def testWriteICalendarUnicodeBug3338(self): event = Calendar.CalendarEvent(itsView=self.view) event.summary = u"unicode \u0633\u0644\u0627\u0645" event.startTime = datetime.datetime(2010, 1, 1, 10, tzinfo=self.view.tzinfo.default) event.endTime = datetime.datetime(2010, 1, 1, 11, tzinfo=self.view.tzinfo.default) event.rruleset = self._makeRecurrenceRuleSet() coll = ListCollection("testcollection", itsParent=self.sandbox) coll.displayName = "test" coll.add(event.itsItem) # the view needs to be committed for event to be seen by sync self.view.commit() filename = u"unicode_export.ics" def delFile(): try: os.remove(filename) except OSError: pass delFile() sharing.exportFile(self.view, os.path.join(".", filename), coll) cal = vobject.readComponents(file(filename, 'rb')).next() self.assertEqual(cal.vevent.summary.value, event.summary) # no modifications should be serialized self.assertEqual(len(cal.vevent_list), 1) delFile()
def testCalendar(self): """ Simple test for creating instances of calendar related kinds """ def getEventValue(event, attrName): try: attrName = getattr(type(event), attrName).name except AttributeError: pass return getattr(event.itsItem, attrName) def _verifyCalendarEvent(event): self.failUnless(stamping.has_stamp(event, Calendar.EventStamp)) self.assertEqual(event.summary, uw("simple headline")) self.assertEqual(event.itsItem.importance, 'fyi') self.assertEqual(getEventValue(event, 'importance'), 'fyi') self.assertEqual(event.transparency, "confirmed") self.assertEqual(getEventValue(event, 'transparency'), "confirmed") self.assertEqual(event.allDay, False) self.assertEqual(getEventValue(event, 'allDay'), False) self.assertEqual(event.anyTime, True) self.assertEqual(getEventValue(event, 'anyTime'), True) def _verifyCalendarItems(location, recurrence): self.assertEqual(location.displayName, uw("simple location")) # Check that the globals got created by the parcel calendarPath = Path('//parcels/osaf/pim/calendar') view = self.sandbox.itsView self.assertEqual(schema.itemFor(Calendar.EventStamp, view), view.find(Path(calendarPath, 'EventStamp'))) self.assertEqual(Calendar.Location.getKind(view), view.find(Path(calendarPath, 'Location'))) self.assertEqual(Calendar.RecurrencePattern.getKind(view), view.find(Path(calendarPath, 'RecurrencePattern'))) # Construct a sample item calendarEventItem = Calendar.CalendarEvent("calendarEventItem", itsParent=self.sandbox) locationItem = Calendar.Location("locationItem", itsParent=self.sandbox) recurrenceItem = Calendar.RecurrencePattern("recurrenceItem", itsParent=self.sandbox) # CalendarEvent properties calendarEventItem.summary = uw("simple headline") calendarEventItem.itsItem.importance = "fyi" _verifyCalendarEvent(calendarEventItem) calendarEventItem.location = locationItem # Calendar properties locationItem.displayName = uw("simple location") _verifyCalendarItems(locationItem, recurrenceItem) # Check cloud membership - event + location items = calendarEventItem.itsItem.getItemCloud('copying') self.assertEqual(len(items), 2) # Re-examine items self.reopenRepository() view = self.sandbox.itsView calendarEventItem = Calendar.EventStamp( self.sandbox.getItemChild("calendarEventItem")) locationItem = self.sandbox.getItemChild("locationItem") recurrenceItem = self.sandbox.getItemChild("recurrenceItem") _verifyCalendarEvent(calendarEventItem) _verifyCalendarItems(locationItem, recurrenceItem)
def testCalendar(self): """ Simple test for creating instances of calendar related kinds """ self.loadParcel("parcel:osaf.pim.calendar") def _verifyCalendarEvent(event): self.assertEqual(event.displayName, "simple headline") self.assertEqual(event.getItemDisplayName(), "simple headline") self.assertEqual(event.importance, 'fyi') self.assertEqual(event.getAttributeValue('importance'), 'fyi') self.assertEqual(event.transparency, "confirmed") self.assertEqual(event.getAttributeValue('transparency'), "confirmed") self.assertEqual(event.allDay, False) self.assertEqual(event.getAttributeValue('allDay'), False) self.assertEqual(event.anyTime, True) self.assertEqual(event.getAttributeValue('anyTime'), True) def _verifyCalendarItems(calendar, location, recurrence): self.assertEqual(calendar.displayName, "simple calendar") self.assertEqual(calendar.getAttributeValue('displayName'), "simple calendar") self.assertEqual(location.displayName, "simple location") self.assertEqual(location.getAttributeValue('displayName'), "simple location") # Check that the globals got created by the parcel calendarPath = Path('//parcels/osaf/pim/calendar') view = self.rep.view self.assertEqual(Calendar.CalendarEvent.getKind(view), view.find(Path(calendarPath, 'CalendarEvent'))) self.assertEqual(Calendar.Calendar.getKind(view), view.find(Path(calendarPath, 'Calendar'))) self.assertEqual(Calendar.Location.getKind(view), view.find(Path(calendarPath, 'Location'))) self.assertEqual(Calendar.RecurrencePattern.getKind(view), view.find(Path(calendarPath, 'RecurrencePattern'))) # Construct a sample item calendarEventItem = Calendar.CalendarEvent("calendarEventItem", view=view) calendarItem = Calendar.Calendar("calendarItem", view=view) locationItem = Calendar.Location("locationItem", view=view) recurrenceItem = Calendar.RecurrencePattern("recurrenceItem", view=view) # CalendarEvent properties calendarEventItem.displayName = "simple headline" calendarEventItem.importance = "fyi" _verifyCalendarEvent(calendarEventItem) calendarEventItem.location = locationItem # Calendar properties calendarItem.displayName = "simple calendar" locationItem.displayName = "simple location" _verifyCalendarItems(calendarItem, locationItem, recurrenceItem) # Check cloud membership - event + location items = calendarEventItem.getItemCloud('copying') self.assertEqual(len(items), 2) # Re-examine items self._reopenRepository() contentItemParent = self.rep.findPath("//userdata") calendarEventItem = contentItemParent.getItemChild("calendarEventItem") calendarItem = contentItemParent.getItemChild("calendarItem") locationItem = contentItemParent.getItemChild("locationItem") recurrenceItem = contentItemParent.getItemChild("recurrenceItem") _verifyCalendarEvent(calendarEventItem) _verifyCalendarItems(calendarItem, locationItem, recurrenceItem)
def testStamping(self): view = self.sandbox.itsView # Get the stamp kinds mailStamp = Mail.MailStamp taskStamp = pim.TaskStamp eventStamp = Calendar.EventStamp noteKind = pim.Note.getKind(view) # start out with a Note aNote = pim.Note("noteItem1", itsParent=self.sandbox) self.setAttributes(aNote, doWho=False) self.assertAttributes(aNote) add = 'add' remove = 'remove' # stamp everything on and off the note self.traverseStampSquence(aNote, ((add, mailStamp), (add, taskStamp), (add, eventStamp), (remove, eventStamp), (remove, taskStamp), (remove, mailStamp))) # stamp everything on again, remove in a different order self.traverseStampSquence(aNote, ((add, mailStamp), (add, taskStamp), (add, eventStamp), (remove, mailStamp), (remove, taskStamp), (remove, eventStamp))) self.assertAttributes(aNote) # Create a Task, and do all kinds of stamping on it aTask = pim.Task("aTask", itsParent=self.sandbox).itsItem self.setAttributes(aTask) self.traverseStampSquence(aTask, ((add, eventStamp), (remove, taskStamp))) # now it's an Event self.traverseStampSquence(aTask, ((add, mailStamp), (remove, mailStamp))) self.traverseStampSquence(aTask, ((add, mailStamp), (add, taskStamp), (remove, mailStamp), (remove, taskStamp))) self.traverseStampSquence(aTask, ((add, taskStamp), (add, mailStamp), (remove, mailStamp), (remove, taskStamp))) self.traverseStampSquence(aTask, ((add, mailStamp), (remove, eventStamp))) # now it's a Mail self.traverseStampSquence(aTask, ((add, taskStamp), (remove, mailStamp))) # it's a Task again self.traverseStampSquence(aTask, ((add, mailStamp), (remove, taskStamp))) self.traverseStampSquence(aTask, ((add, taskStamp), (remove, mailStamp))) # it's a Task again self.traverseStampSquence(aTask, ((add, eventStamp), (remove, taskStamp), (add, mailStamp), (remove, eventStamp), (add, taskStamp), (remove, mailStamp))) self.failUnless(has_stamp(aTask, taskStamp)) # check stamping on an Event anEvent = Calendar.CalendarEvent("anEvent", itsParent=self.sandbox).itsItem self.setAttributes(anEvent) # round-robin its Kind back to event self.traverseStampSquence(anEvent, ((add, mailStamp), (remove, eventStamp), (add, taskStamp), (remove, mailStamp), (add, eventStamp), (remove, taskStamp))) self.failUnless(has_stamp(anEvent, eventStamp)) # check stamping on a Mail Message aMessage = Mail.MailMessage("aMessage", itsParent=self.sandbox).itsItem self.setAttributes(aMessage) self.traverseStampSquence(aMessage, ((add, eventStamp), (add, taskStamp), (remove, eventStamp), (remove, taskStamp))) self.failUnless(has_stamp(aMessage, mailStamp)) # now mixin some arbitrary Kind #anotherKind = view.findPath('//parcels/osaf/framework/blocks/Block') # stamp an event, mail, task with another kind #aNote.StampKind(add, anotherKind) #aTask.StampKind(add, anotherKind) #anEvent.StampKind(add, anotherKind) #aMessage.StampKind(add, anotherKind) #self.assertKinds(aNote, (noteKind, anotherKind)) #self.assertKinds(aTask, (taskKind, anotherKind)) #self.assertKinds(anEvent, (eventKind, anotherKind)) #self.assertKinds(aMessage, (mailKind, anotherKind)) # unstamp with another kind #aNote.StampKind(remove, anotherKind) #aTask.StampKind(remove, anotherKind) #anEvent.StampKind(remove, anotherKind) #aMessage.StampKind(remove, anotherKind) # see that they still have their attributes #self.assertKinds(aNote, (noteKind, )) #self.assertKinds(aTask, (taskKind, )) #self.assertKinds(anEvent, (eventKind, )) #self.assertKinds(aMessage, (mailKind, )) # Test some failure cases # These cases should produce suitable warning messages in Chandler.log if testFailureCases: anotherEvent = Calendar.CalendarEvent( "anotherEvent", itsParent=self.sandbox).itsItem self.setAttributes(anotherEvent) self.failUnless(has_stamp(anotherEvent, eventStamp)) # Could use assertRaises here, but it's syntax with respect to parameters is # not clear with my complex arguments, so try/except/else is more readable. try: # double stamping self.traverseStampSquence(anotherEvent, ((add, mailStamp), (add, mailStamp))) except StampAlreadyPresentError: pass else: self.failUnless(False, "Double stamping should raise an exception!") try: # unstamping something not present self.traverseStampSquence(anotherEvent, ((remove, taskStamp), )) except StampNotPresentError: pass else: self.failUnless( False, "Unstamping a stamp not present should raise an exception!" ) # Test for Bug:6151: Make sure items don't disappear # from the all collection if they're unstamped # # Make an email ... aMessage = Mail.MailMessage("aNewMessage", itsParent=self.sandbox) self.setAttributes(aMessage.itsItem) # Make sure it's in "Out" aMessage.fromMe = True outCollection = schema.ns("osaf.pim", view).outCollection self.failUnless(aMessage.itsItem in outCollection) # unstamp its emailness self.traverseStampSquence(aMessage.itsItem, (('add', taskStamp), ('remove', mailStamp))) allCollection = schema.ns("osaf.pim", view).allCollection self.failUnless(aMessage.itsItem in allCollection)