def testResetRecurrence(self):
self.task1.setRecurrence(date.Recurrence('weekly'))
self.edit([self.task1], edits=[self.task1.setRecurrence])
self.assertDoUndoRedo(
lambda: self.failIf(self.task1.recurrence()),
lambda: self.assertEqual(date.Recurrence('weekly'),
self.task1.recurrence()))
def testMarkParentWithRecurringChildCompleted_RemovesChildRecurrence(self):
self.child.setRecurrence(date.Recurrence('daily'))
self.markCompleted([self.parent])
self.assertDoUndoRedo(
lambda: self.failIf(self.child.recurrence()),
lambda: self.assertEqual(date.Recurrence('daily'),
self.child.recurrence()))
def fillContainers(self):
# pylint: disable-msg=W0201
self.description = 'Description\nLine 2'
self.task = task.Task(subject='Subject', description=self.description,
startDateTime=date.Now() - date.TimeDelta(days=1),
dueDateTime=date.Now() + date.TimeDelta(days=1),
completionDateTime=date.Now() - date.TimeDelta(days=1),
budget=date.TimeDelta(hours=1),
priority=4, hourlyFee=100.5, fixedFee=1000,
recurrence=date.Recurrence('weekly', max=10, count=5, amount=2),
reminder=date.DateTime(2004,1,1), fgColor=wx.BLUE, bgColor=wx.RED,
font=wx.NORMAL_FONT, expandedContexts=['viewer1'], icon='icon',
selectedIcon='selectedIcon',
shouldMarkCompletedWhenAllChildrenCompleted=True,
percentageComplete=67)
self.child = task.Task()
self.task.addChild(self.child)
self.grandChild = task.Task()
self.child.addChild(self.grandChild)
self.task.addEffort(effort.Effort(self.task, start=date.DateTime(2004,1,1),
stop=date.DateTime(2004,1,2), description=self.description))
self.category = category.Category('test', [self.task], filtered=True,
description='Description',
exclusiveSubcategories=True)
self.categories.append(self.category)
# pylint: disable-msg=E1101
self.task.addAttachments(attachment.FileAttachment('/home/frank/whatever.txt'))
self.task.addNote(note.Note(subject='Task note'))
self.task2 = task.Task('Task 2', priority=-1954)
self.taskList.extend([self.task, self.task2])
self.note = note.Note(subject='Note', description='Description',
children=[note.Note(subject='Child')])
self.notes.append(self.note)
self.category.addCategorizable(self.note)
def testMarkRecurringTaskCompleted_ActualStartDateIsReset(self):
self.task1.setRecurrence(date.Recurrence('weekly'))
now = date.Now()
self.task1.setActualStartDateTime(now)
self.markCompleted([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(date.DateTime(), self.task1.actualStartDateTime()),
lambda: self.assertEqual(now, self.task1.actualStartDateTime()))
def testMarkRecurringTaskCompleted_PlannedStartDateIsIncreased(self):
self.task1.setRecurrence(date.Recurrence('weekly'))
plannedStartDateTime = self.task1.plannedStartDateTime()
newPlannedStartDateTime = plannedStartDateTime + date.TimeDelta(days=7)
self.markCompleted([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(newPlannedStartDateTime, self.task1.plannedStartDateTime()),
lambda: self.assertEqual(plannedStartDateTime, self.task1.plannedStartDateTime()))
def testMarkLastChildCompletedMakesParentRecur_AndThusChildIsNotCompleted(
self):
self.parent.setRecurrence(date.Recurrence('weekly'))
self.child.setCompletionDateTime()
if self.shouldMarkCompletedWhenAllChildrenCompleted(self.parent):
self.failIf(self.child.completed())
else:
self.failUnless(self.child.completed())
def __parse_recurrence(self, task_node):
''' Parse the recurrence from the node and return a recurrence
instance. '''
if self.__tskversion <= 19:
parse_kwargs = self.__parse_recurrence_attributes_from_task_node
else:
parse_kwargs = self.__parse_recurrence_node
return date.Recurrence(**parse_kwargs(task_node))
def createTasks(self):
# pylint: disable=W0201
self.task = task.Task('Task to edit')
self.stop_datetime = date.DateTime(2012, 12, 12, 12, 12)
self.task.setRecurrence( \
date.Recurrence('daily', amount=1,
stop_datetime=self.stop_datetime))
return [self.task]
def __init__(
self,
subject='',
description='',
dueDateTime=None,
startDateTime=None,
completionDateTime=None,
budget=None,
priority=0,
id=None,
hourlyFee=0, # pylint: disable-msg=W0622
fixedFee=0,
reminder=None,
categories=None,
efforts=None,
shouldMarkCompletedWhenAllChildrenCompleted=None,
recurrence=None,
percentageComplete=0,
prerequisites=None,
dependencies=None,
*args,
**kwargs):
kwargs['id'] = id
kwargs['subject'] = subject
kwargs['description'] = description
kwargs['categories'] = categories
super(Task, self).__init__(*args, **kwargs)
self.__dueDateTime = base.Attribute(dueDateTime or date.DateTime(),
self, self.dueDateTimeEvent)
self.__startDateTime = base.Attribute(startDateTime or date.DateTime(),
self, self.startDateTimeEvent)
self.__completionDateTime = base.Attribute(
completionDateTime or date.DateTime(), self,
self.completionDateTimeEvent)
percentageComplete = 100 if self.__completionDateTime.get(
) != date.DateTime() else percentageComplete
self.__percentageComplete = base.Attribute(
percentageComplete, self, self.percentageCompleteEvent)
self.__budget = base.Attribute(budget or date.TimeDelta(), self,
self.budgetEvent)
self._efforts = efforts or []
self.__priority = base.Attribute(priority, self, self.priorityEvent)
self.__hourlyFee = base.Attribute(hourlyFee, self, self.hourlyFeeEvent)
self.__fixedFee = base.Attribute(fixedFee, self, self.fixedFeeEvent)
self.__reminder = base.Attribute(reminder, self, self.reminderEvent)
self._recurrence = date.Recurrence(
) if recurrence is None else recurrence
self.__prerequisites = base.SetAttribute(
prerequisites or [], self, changeEvent=self.prerequisitesEvent)
self.__dependencies = base.SetAttribute(
dependencies or [], self, changeEvent=self.dependenciesEvent)
self._shouldMarkCompletedWhenAllChildrenCompleted = \
shouldMarkCompletedWhenAllChildrenCompleted
for effort in self._efforts:
effort.setTask(self)
for eventType in 'active', 'inactive', 'completed', 'duesoon', 'overdue':
patterns.Publisher().registerObserver(
self.__computeRecursiveForegroundColor, 'color.%stasks')
def testMarkRecurringTaskCompleted_DueDateIsIncreased(self):
self.task1.setRecurrence(date.Recurrence('weekly'))
tomorrow = date.Tomorrow()
self.task1.setDueDateTime(tomorrow)
newDueDate = tomorrow + date.ONE_WEEK
self.markCompleted([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(newDueDate, self.task1.dueDateTime()),
lambda: self.assertEqual(tomorrow, self.task1.dueDateTime()))
def testMarkLastChildCompletedMakesParentRecur(self):
self.parent.setPlannedStartDateTime(self.now)
self.parent.setRecurrence(date.Recurrence('weekly'))
self.child.setCompletionDateTime(self.now)
expectedPlannedStartDateTime = self.now
if self.shouldMarkCompletedWhenAllChildrenCompleted(self.parent):
expectedPlannedStartDateTime += date.TimeDelta(days=7)
self.assertAlmostEqual(expectedPlannedStartDateTime.toordinal(),
self.parent.plannedStartDateTime().toordinal())
def testMarkLastChildCompletedMakesParentRecur_AndThusChildToo(self):
self.parent.setRecurrence(date.Recurrence('weekly'))
self.child.setCompletionDateTime(self.now)
if self.shouldMarkCompletedWhenAllChildrenCompleted(self.parent):
expectedStartDateTime = self.now + date.TimeDelta(days=7)
self.assertAlmostEqual(expectedStartDateTime.toordinal(),
self.child.startDateTime().toordinal())
else:
self.assertAlmostEqual(self.now.toordinal(),
self.child.startDateTime().toordinal())
def GetValue(self):
recurrenceDict = {
0: '',
1: 'daily',
2: 'weekly',
3: 'monthly',
4: 'yearly'
}
kwargs = dict(
unit=recurrenceDict[self._recurrencePeriodEntry.Selection])
if self._maxRecurrenceCheckBox.IsChecked():
kwargs['maximum'] = self._maxRecurrenceCountEntry.Value
kwargs['amount'] = self._recurrenceFrequencyEntry.Value
kwargs['sameWeekday'] = self._recurrenceSameWeekdayCheckBox.IsChecked()
kwargs['recurBasedOnCompletion'] = bool(self._scheduleChoice.Selection)
if self._stopDateTimeCheckBox.IsChecked():
kwargs[
'stop_datetime'] = self._recurrenceStopDateTimeEntry.GetValue(
)
return date.Recurrence(**kwargs) # pylint: disable=W0142
def testWeeklyRecurrence(self):
self.assertEqual(_('Weekly'),
render.recurrence(date.Recurrence('weekly')))
def testThreeYearly(self):
self.assertEqual('Every 3 years',
render.recurrence(date.Recurrence('yearly', 3)))
def testThreeMonthly(self):
self.assertEqual('Every 3 months',
render.recurrence(date.Recurrence('monthly', 3)))
def testThreeWeekly(self):
self.assertEqual(
'Every 3 weeks',
render.recurrence(date.Recurrence('weekly', amount=3)))
def testThreeDaily(self):
self.assertEqual('Every 3 days',
render.recurrence(date.Recurrence('daily', amount=3)))
def testEveryOtherYear(self):
self.assertEqual(
_('Every other year'),
render.recurrence(date.Recurrence('yearly', amount=2)))
def testEveryOtherMonth(self):
self.assertEqual(
_('Every other month'),
render.recurrence(date.Recurrence('monthly', amount=2)))
def testEveryOtherWeek(self):
self.assertEqual(
_('Every other week'),
render.recurrence(date.Recurrence('weekly', amount=2)))
def testSetRecurrenceFrequency(self):
self.setRecurrence(date.Recurrence('weekly', amount=3))
self.assertEqual(3, self.task.recurrence().amount)
def testSetMaxRecurrence(self):
self.setRecurrence(date.Recurrence('weekly', maximum=10))
self.assertEqual(10, self.task.recurrence().max)
def testSetDailyRecurrence(self):
self.setRecurrence(date.Recurrence('daily', amount=1))
self.assertEqual('daily', self.task.recurrence().unit)
self.assertEqual(1, self.task.recurrence().amount)
def testSetYearlyRecurrence(self):
self.setRecurrence(date.Recurrence('yearly'))
self.assertEqual('yearly', self.task.recurrence().unit)
def testMonthlyRecurrence(self):
self.assertEqual(_('Monthly'),
render.recurrence(date.Recurrence('monthly')))
def testSetRecurrenceStopDateTime(self):
stop = date.DateTime(2012, 3, 4, 10, 0)
self.setRecurrence(date.Recurrence('weekly', stop_datetime=stop))
self.assertEqual(stop, self.task.recurrence().stop_datetime)
def testYearlyRecurrence(self):
self.assertEqual(_('Yearly'),
render.recurrence(date.Recurrence('yearly')))
def testSetRecurrenceSameWeekday(self):
self.setRecurrence(date.Recurrence('monthly', sameWeekday=True))
self.failUnless(self.task.recurrence().sameWeekday)
def testEveryOtherDay(self):
self.assertEqual(_('Every other day'),
render.recurrence(date.Recurrence('daily', amount=2)))
