Python models.Task类代码示例

 def test_is_available_filter_after_end_date(self):
     """
     If it is after a task's end date, the task should not be
     available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2014, 2, 1)))
     ok_(self.task_end_jan not in tasks)

 def test_is_available_filter_in_range(self):
     """
     If the current date is within a task's date range, the task
     should be available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2014, 1, 5)))
     ok_(self.task_range_jan_feb in tasks)

 def test_is_available_filter_after_start_date(self):
     """
     If it is after a task's start date, the task should be
     available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2014, 2, 1)))
     ok_(self.task_start_jan in tasks)

 def test_is_available_filter_invalid(self):
     """
     If a task is marked as invalid, it should not be available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2014, 1, 2)))
     ok_(self.task_no_draft in tasks)
     ok_(self.task_invalid not in tasks)

 def test_is_available_filter_before_start_date(self):
     """
     If it is before a task's start date, the task should not be
     available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2013, 12, 1)))
     ok_(self.task_start_jan not in tasks)

 def test_invalidate_tasks_not_equals_criterion(self):
     """
     The invalidate_tasks routine should invalidate tasks which match the
     invalidation criteria.
     This tests a not equals criterion.
     """
     bug_to_become_invalid, bug_to_stay_valid = BugzillaBugFactory.create_batch(2)
     batch = TaskImportBatchFactory.create()
     criterion = TaskInvalidationCriterionFactory.create(
         field_name='name',
         relation=TaskInvalidationCriterion.NOT_EQUAL,
         field_value='value')
     criterion.batches.add(batch)
     criterion.save()
     task1, task2 = TaskFactory.create_batch(2,
                                             batch=batch,
                                             imported_item=bug_to_become_invalid,
                                             is_invalid=False)
     task2.imported_item = bug_to_stay_valid
     task2.save()
     with patch('oneanddone.tasks.models.BugzillaUtils.request_bug') as request_bug:
         request_bug.side_effect = lambda x: {
             bug_to_become_invalid.bugzilla_id: {'name': 'value'},
             bug_to_stay_valid.bugzilla_id: {'name': 'not value'}}[x]
         eq_(Task.invalidate_tasks(), 1)
     eq_(Task.objects.get(pk=task1.pk).is_invalid, False)
     eq_(Task.objects.get(pk=task2.pk).is_invalid, True)

 def handle(self, *args, **options):
     invalidated = Task.invalidate_tasks()
     self.stdout.write('%s: %s tasks were invalidated via bug data\n' %
                       (datetime.now().isoformat(), invalidated))
     closed = TaskAttempt.close_stale_onetime_attempts()
     self.stdout.write('%s: %s stale one-time attempts were closed\n' %
                       (datetime.now().isoformat(), closed))
     closed = TaskAttempt.close_expired_task_attempts()
     self.stdout.write('%s: %s attempts for expired tasks were closed\n' %
                       (datetime.now().isoformat(), closed))

 def test_is_available_filter_default_now(self):
     """
     If no timezone is given, is_available_filter should use
     timezone.now to determine the current datetime.
     """
     with patch('oneanddone.tasks.models.timezone.now') as now:
         now.return_value = aware_datetime(2014, 1, 5)
         tasks = Task.objects.filter(Task.is_available_filter())
         expected = [self.task_no_draft, self.task_start_jan, self.task_range_jan_feb]
         eq_(set(tasks), set(expected))

    def __init__(self, *args, **kwargs):
        super(AvailableTasksFilterSet, self).__init__(*args, **kwargs)

        # Limit the area filter to TaskAreas that have available tasks.
        available_areas = TaskArea.objects.filter(Task.is_available_filter(prefix='task__')).distinct()
        ancestor_querysets = [area.get_ancestors(include_self=True) for area in available_areas]
        self.filters['area'] = TreeFilter(
            name='area',
            queryset=reduce(operator.or_, ancestor_querysets).distinct(),
            empty_label=u'All Areas'
        )

 def test_is_available_filter_default_now(self):
     """
     If no timezone is given, is_available_filter should use
     timezone.now to determine the current datetime.
     This also tests the repeatable aspect of the filter by
     ensuring that tasks with attempts that are started or
     finished are not included, but those with no attempts
     or abandoned attempts are included.
     """
     with patch('oneanddone.tasks.models.timezone.now') as now:
         now.return_value = aware_datetime(2014, 1, 5)
         tasks = Task.objects.filter(Task.is_available_filter())
         expected = [self.task_not_repeatable_no_attempts,
                     self.task_not_repeatable_abandoned_attempt,
                     self.task_no_draft, self.task_start_jan,
                     self.task_range_jan_feb]
         eq_(set(tasks), set(expected))

 def get_queryset(self):
     queryset = super(TaskMustBeAvailableMixin, self).get_queryset()
     return queryset.filter(Task.is_available_filter(allow_expired=self.allow_expired_tasks))

 def test_is_available_filter_before_end_date(self):
     """
     If it is before a task's end date, the task should be available.
     """
     tasks = Task.objects.filter(Task.is_available_filter(now=aware_datetime(2013, 12, 1)))
     ok_(self.task_end_jan in tasks)