Exemple #1
0
    def setUp(self):
        self.builder_run = False

        def builder(schedule):
            self.builder_run = True
            # This should be something that will be a different object every
            # time
            return timezone.now()

        self.start = timezone.now()
        self.range = timedelta(days=1)
        self.sched = Schedule(self.start, self.range, builder)
        self.builder = builder
Exemple #2
0
class ScheduleTests(TestCase):
    """
    Tests that the :class:`Schedule` class behaves itself in the general case,
    using a stub builder.

    """
    def setUp(self):
        self.builder_run = False

        def builder(schedule):
            self.builder_run = True
            # This should be something that will be a different object every
            # time
            return timezone.now()

        self.start = timezone.now()
        self.range = timedelta(days=1)
        self.sched = Schedule(self.start, self.range, builder)
        self.builder = builder

    def test_test_consistency(self):
        """
        Make sure the test itself makes sense!

        """
        self.assertFalse(self.builder_run)
        self.builder(None)
        self.assertTrue(self.builder_run)

    def test_init_laziness(self):
        """Ensure that laziness holds immediately after __init__.

        That is, the schedule data has not been precomputed.
        """
        self.assertFalse(self.builder_run)

    def test_attributes(self):
        """Test the basic attributes of Schedule.
        """
        self.assertEqual(self.sched.start, self.start)
        self.assertEqual(self.sched.range, self.range)

    def test_previous_next_start_range(self):
        """Ensure that Schedule.prev and Schedule.next work properly.

        That is, that Schedule.prev and Schedule.next return new schedule
        objects that represent the schedules one range before and after the
        current schedule respectively.
        """
        prev = self.sched.previous()
        self.assertIsNot(prev, self.sched)
        self.assertEqual(prev.start, self.start - self.range)
        self.assertEqual(prev.range, self.range)

        next = self.sched.next()
        self.assertIsNot(next, self.sched)
        self.assertEqual(next.start, self.start + self.range)
        self.assertEqual(next.range, self.range)

        self.assertIsNot(prev, next)

    def test_previous_next_laziness(self):
        """
        Ensure that laziness is preserved when calling :meth:`Schedule.prev`
        and :meth:`Schedule.next`; if the data has not been evaluated, it
        will not be evaluated by calling these functions.

        """
        self.sched.previous()
        self.assertFalse(self.builder_run)

        self.sched.next()
        self.assertFalse(self.builder_run)

    def test_get(self):
        """
        Ensure that running :meth:`Schedule.get` evaluates the schedule builder
        and populates :attr:`Schedule.data`, which should be the result of the
        function.

        """
        result = self.sched.data
        self.assertIsNotNone(result)
        self.assertTrue(self.builder_run)

        # Make sure get doesn't re-run the builder
        self.builder_run = False
        result2 = self.sched.data
        self.assertIs(result2, result)
        self.assertFalse(self.builder_run)