Fixed #10154: Allow combining F expressions with timedelta values.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15018 bcc190cf-cafb-0310-a4f2-bffc1f526a37

2 files changed, 218 insertions, 2 deletions

diff --git a/tests/regressiontests/expressions_regress/models.py b/tests/regressiontests/expressions_regress/models.py
index f2997ee5be..56c3746b91 100644
--- a/tests/regressiontests/expressions_regress/models.py
+++ b/tests/regressiontests/expressions_regress/models.py
@@ -10,3 +10,16 @@ class Number(models.Model):
     def __unicode__(self):
         return u'%i, %.3f' % (self.integer, self.float)
 
+class Experiment(models.Model):
+    name = models.CharField(max_length=24)
+    assigned = models.DateField()
+    completed = models.DateField()
+    start = models.DateTimeField()
+    end = models.DateTimeField()
+
+    class Meta:
+        ordering = ('name',)
+
+    def duration(self):
+        return self.end - self.start
+
diff --git a/tests/regressiontests/expressions_regress/tests.py b/tests/regressiontests/expressions_regress/tests.py
index 67632f48bb..a900c6c5fd 100644
--- a/tests/regressiontests/expressions_regress/tests.py
+++ b/tests/regressiontests/expressions_regress/tests.py
@@ -1,12 +1,14 @@
 """
 Spanning tests for all the operations that F() expressions can perform.
 """
+import datetime
+
 from django.conf import settings
-from django.db import models, DEFAULT_DB_ALIAS
+from django.db import models, connection
 from django.db.models import F
 from django.test import TestCase, Approximate, skipUnlessDBFeature
 
-from regressiontests.expressions_regress.models import Number
+from regressiontests.expressions_regress.models import Number, Experiment
 
 
 class ExpressionsRegressTests(TestCase):
@@ -193,3 +195,204 @@ class ExpressionOperatorTests(TestCase):
         self.assertEqual(Number.objects.get(pk=self.n.pk).integer, 47)
         self.assertEqual(Number.objects.get(pk=self.n.pk).float, Approximate(15.500, places=3))
 
+class FTimeDeltaTests(TestCase):
+
+    def setUp(self):
+        sday = datetime.date(2010, 6, 25)
+        stime = datetime.datetime(2010, 6, 25, 12, 15, 30, 747000)
+        midnight = datetime.time(0)
+
+        delta0 = datetime.timedelta(0)
+        delta1 = datetime.timedelta(microseconds=253000)
+        delta2 = datetime.timedelta(seconds=44)
+        delta3 = datetime.timedelta(hours=21, minutes=8)
+        delta4 = datetime.timedelta(days=10)
+
+        # Test data is set so that deltas and delays will be
+        # strictly increasing.
+        self.deltas = []
+        self.delays = []
+        self.days_long = []
+
+        # e0: started same day as assigned, zero duration
+        end = stime+delta0
+        e0 = Experiment.objects.create(name='e0', assigned=sday, start=stime,
+            end=end, completed=end.date())
+        self.deltas.append(delta0)
+        self.delays.append(e0.start-
+            datetime.datetime.combine(e0.assigned, midnight))
+        self.days_long.append(e0.completed-e0.assigned)
+
+        # e1: started one day after assigned, tiny duration, data
+        # set so that end time has no fractional seconds, which
+        # tests an edge case on sqlite. This Experiment is only
+        # included in the test data when the DB supports microsecond
+        # precision.
+        if connection.features.supports_microsecond_precision:
+            delay = datetime.timedelta(1)
+            end = stime + delay + delta1
+            e1 = Experiment.objects.create(name='e1', assigned=sday,
+                start=stime+delay, end=end, completed=end.date())
+            self.deltas.append(delta1)
+            self.delays.append(e1.start-
+                datetime.datetime.combine(e1.assigned, midnight))
+            self.days_long.append(e1.completed-e1.assigned)
+
+        # e2: started three days after assigned, small duration
+        end = stime+delta2
+        e2 = Experiment.objects.create(name='e2',
+            assigned=sday-datetime.timedelta(3), start=stime, end=end, 
+            completed=end.date())
+        self.deltas.append(delta2)
+        self.delays.append(e2.start-
+            datetime.datetime.combine(e2.assigned, midnight))
+        self.days_long.append(e2.completed-e2.assigned)
+
+        # e3: started four days after assigned, medium duration
+        delay = datetime.timedelta(4)
+        end = stime + delay + delta3
+        e3 = Experiment.objects.create(name='e3',
+            assigned=sday, start=stime+delay, end=end, completed=end.date())
+        self.deltas.append(delta3)
+        self.delays.append(e3.start-
+            datetime.datetime.combine(e3.assigned, midnight))
+        self.days_long.append(e3.completed-e3.assigned)
+
+        # e4: started 10 days after assignment, long duration
+        end = stime + delta4
+        e4 = Experiment.objects.create(name='e4',
+            assigned=sday-datetime.timedelta(10), start=stime, end=end,
+            completed=end.date())
+        self.deltas.append(delta4)
+        self.delays.append(e4.start-
+            datetime.datetime.combine(e4.assigned, midnight))
+        self.days_long.append(e4.completed-e4.assigned)
+        self.expnames = [e.name for e in Experiment.objects.all()]
+
+    def test_delta_add(self):
+        for i in range(len(self.deltas)):
+            delta = self.deltas[i]
+            test_set = [e.name for e in
+                Experiment.objects.filter(end__lt=F('start')+delta)]
+            self.assertEqual(test_set, self.expnames[:i])
+
+            test_set = [e.name for e in
+                Experiment.objects.filter(end__lte=F('start')+delta)]
+            self.assertEqual(test_set, self.expnames[:i+1])
+
+    def test_delta_subtract(self):
+        for i in range(len(self.deltas)):
+            delta = self.deltas[i]
+            test_set = [e.name for e in
+                Experiment.objects.filter(start__gt=F('end')-delta)]
+            self.assertEqual(test_set, self.expnames[:i])
+
+            test_set = [e.name for e in
+                Experiment.objects.filter(start__gte=F('end')-delta)]
+            self.assertEqual(test_set, self.expnames[:i+1])
+
+    def test_exclude(self):
+        for i in range(len(self.deltas)):
+            delta = self.deltas[i]
+            test_set = [e.name for e in 
+                Experiment.objects.exclude(end__lt=F('start')+delta)]
+            self.assertEqual(test_set, self.expnames[i:])
+
+            test_set = [e.name for e in 
+                Experiment.objects.exclude(end__lte=F('start')+delta)]
+            self.assertEqual(test_set, self.expnames[i+1:])
+
+    def test_date_comparison(self):
+        for i in range(len(self.days_long)):
+            days = self.days_long[i]
+            test_set = [e.name for e in 
+                Experiment.objects.filter(completed__lt=F('assigned')+days)]
+            self.assertEqual(test_set, self.expnames[:i])
+
+            test_set = [e.name for e in 
+                Experiment.objects.filter(completed__lte=F('assigned')+days)]
+            self.assertEqual(test_set, self.expnames[:i+1])
+
+    @skipUnlessDBFeature("supports_mixed_date_datetime_comparisons")
+    def test_mixed_comparisons1(self):
+        for i in range(len(self.delays)):
+            delay = self.delays[i]
+            if not connection.features.supports_microsecond_precision:
+                delay = datetime.timedelta(delay.days, delay.seconds)
+            test_set = [e.name for e in
+                Experiment.objects.filter(assigned__gt=F('start')-delay)]
+            self.assertEqual(test_set, self.expnames[:i])
+
+            test_set = [e.name for e in
+                Experiment.objects.filter(assigned__gte=F('start')-delay)]
+            self.assertEqual(test_set, self.expnames[:i+1])
+
+    def test_mixed_comparisons2(self):
+        delays = [datetime.timedelta(delay.days) for delay in self.delays]
+        for i in range(len(delays)):
+            delay = delays[i]
+            test_set = [e.name for e in
+                Experiment.objects.filter(start__lt=F('assigned')+delay)]
+            self.assertEqual(test_set, self.expnames[:i])
+
+            test_set = [e.name for e in
+                Experiment.objects.filter(start__lte=F('assigned')+delay+
+                    datetime.timedelta(1))]
+            self.assertEqual(test_set, self.expnames[:i+1])
+
+    def test_delta_update(self):
+        for i in range(len(self.deltas)):
+            delta = self.deltas[i]
+            exps = Experiment.objects.all()
+            expected_durations = [e.duration() for e in exps]
+            expected_starts = [e.start+delta for e in exps]
+            expected_ends = [e.end+delta for e in exps]
+
+            Experiment.objects.update(start=F('start')+delta, end=F('end')+delta)
+            exps = Experiment.objects.all()
+            new_starts = [e.start for e in exps]
+            new_ends = [e.end for e in exps]
+            new_durations = [e.duration() for e in exps]
+            self.assertEqual(expected_starts, new_starts)
+            self.assertEqual(expected_ends, new_ends)
+            self.assertEqual(expected_durations, new_durations)
+
+    def test_delta_invalid_op_mult(self):
+        raised = False
+        try:
+            r = repr(Experiment.objects.filter(end__lt=F('start')*self.deltas[0]))
+        except TypeError:
+            raised = True
+        self.assertTrue(raised, "TypeError not raised on attempt to multiply datetime by timedelta.")
+
+    def test_delta_invalid_op_div(self):
+        raised = False
+        try:
+            r = repr(Experiment.objects.filter(end__lt=F('start')/self.deltas[0]))
+        except TypeError:
+            raised = True
+        self.assertTrue(raised, "TypeError not raised on attempt to divide datetime by timedelta.")
+
+    def test_delta_invalid_op_mod(self):
+        raised = False
+        try:
+            r = repr(Experiment.objects.filter(end__lt=F('start')%self.deltas[0]))
+        except TypeError:
+            raised = True
+        self.assertTrue(raised, "TypeError not raised on attempt to modulo divide datetime by timedelta.")
+
+    def test_delta_invalid_op_and(self):
+        raised = False
+        try:
+            r = repr(Experiment.objects.filter(end__lt=F('start')&self.deltas[0]))
+        except TypeError:
+            raised = True
+        self.assertTrue(raised, "TypeError not raised on attempt to binary and a datetime with a timedelta.")
+
+    def test_delta_invalid_op_or(self):
+        raised = False
+        try:
+            r = repr(Experiment.objects.filter(end__lt=F('start')|self.deltas[0]))
+        except TypeError:
+            raised = True
+        self.assertTrue(raised, "TypeError not raised on attempt to binary or a datetime with a timedelta.")