Debian Codegraph @

tests/timezones/tests.py

raw
1 import datetime
2 import re
3 import sys
4 import zoneinfo
5 from contextlib import contextmanager
6 from unittest import SkipTest, skipIf
7 from xml.dom.minidom import parseString
8
9 from django.contrib.auth.models import User
10 from django.core import serializers
11 from django.db import connection
12 from django.db.models import F, Max, Min
13 from django.db.models.functions import Now
14 from django.http import HttpRequest
15 from django.template import (
16 Context,
17 RequestContext,
18 Template,
19 TemplateSyntaxError,
20 context_processors,
21 )
22 from django.test import (
23 SimpleTestCase,
24 TestCase,
25 TransactionTestCase,
26 override_settings,
27 skipIfDBFeature,
28 skipUnlessDBFeature,
29 )
30 from django.test.utils import requires_tz_support
31 from django.urls import reverse
32 from django.utils import timezone, translation
33 from django.utils.timezone import timedelta
34
35 from .forms import (
36 EventForm,
37 EventLocalizedForm,
38 EventLocalizedModelForm,
39 EventModelForm,
40 EventSplitForm,
41 )
42 from .models import (
43 AllDayEvent,
44 DailyEvent,
45 Event,
46 MaybeEvent,
47 Session,
48 SessionEvent,
49 Timestamp,
50 )
51
52 try:
53 import yaml
54
55 HAS_YAML = True
56 except ImportError:
57 HAS_YAML = False
58
59 # These tests use the EAT (Eastern Africa Time) and ICT (Indochina Time)
60 # who don't have daylight saving time, so we can represent them easily
61 # with fixed offset timezones and use them directly as tzinfo in the
62 # constructors.
63
64 # settings.TIME_ZONE is forced to EAT. Most tests use a variant of
65 # datetime.datetime(2011, 9, 1, 13, 20, 30), which translates to
66 # 10:20:30 in UTC and 17:20:30 in ICT.
67
68 UTC = datetime.timezone.utc
69 EAT = timezone.get_fixed_timezone(180) # Africa/Nairobi
70 ICT = timezone.get_fixed_timezone(420) # Asia/Bangkok
71
72
73 @contextmanager
74 def override_database_connection_timezone(timezone):
75 try:
76 orig_timezone = connection.settings_dict["TIME_ZONE"]
77 connection.settings_dict["TIME_ZONE"] = timezone
78 # Clear cached properties, after first accessing them to ensure they exist.
79 connection.timezone
80 del connection.timezone
81 connection.timezone_name
82 del connection.timezone_name
83 yield
84 finally:
85 connection.settings_dict["TIME_ZONE"] = orig_timezone
86 # Clear cached properties, after first accessing them to ensure they exist.
87 connection.timezone
88 del connection.timezone
89 connection.timezone_name
90 del connection.timezone_name
91
92
93 @override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=False)
94 class LegacyDatabaseTests(TestCase):
95 def test_naive_datetime(self):
96 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
97 Event.objects.create(dt=dt)
98 event = Event.objects.get()
99 self.assertEqual(event.dt, dt)
100
101 def test_naive_datetime_with_microsecond(self):
102 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060)
103 Event.objects.create(dt=dt)
104 event = Event.objects.get()
105 self.assertEqual(event.dt, dt)
106
107 @skipUnlessDBFeature("supports_timezones")
108 def test_aware_datetime_in_local_timezone(self):
109 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
110 Event.objects.create(dt=dt)
111 event = Event.objects.get()
112 self.assertIsNone(event.dt.tzinfo)
113 # interpret the naive datetime in local time to get the correct value
114 self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
115
116 @skipUnlessDBFeature("supports_timezones")
117 def test_aware_datetime_in_local_timezone_with_microsecond(self):
118 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060, tzinfo=EAT)
119 Event.objects.create(dt=dt)
120 event = Event.objects.get()
121 self.assertIsNone(event.dt.tzinfo)
122 # interpret the naive datetime in local time to get the correct value
123 self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
124
125 @skipUnlessDBFeature("supports_timezones")
126 def test_aware_datetime_in_utc(self):
127 dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
128 Event.objects.create(dt=dt)
129 event = Event.objects.get()
130 self.assertIsNone(event.dt.tzinfo)
131 # interpret the naive datetime in local time to get the correct value
132 self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
133
134 @skipUnlessDBFeature("supports_timezones")
135 def test_aware_datetime_in_other_timezone(self):
136 dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT)
137 Event.objects.create(dt=dt)
138 event = Event.objects.get()
139 self.assertIsNone(event.dt.tzinfo)
140 # interpret the naive datetime in local time to get the correct value
141 self.assertEqual(event.dt.replace(tzinfo=EAT), dt)
142
143 @skipIfDBFeature("supports_timezones")
144 def test_aware_datetime_unsupported(self):
145 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
146 msg = "backend does not support timezone-aware datetimes when USE_TZ is False."
147 with self.assertRaisesMessage(ValueError, msg):
148 Event.objects.create(dt=dt)
149
150 def test_auto_now_and_auto_now_add(self):
151 now = datetime.datetime.now()
152 past = now - datetime.timedelta(seconds=2)
153 future = now + datetime.timedelta(seconds=2)
154 Timestamp.objects.create()
155 ts = Timestamp.objects.get()
156 self.assertLess(past, ts.created)
157 self.assertLess(past, ts.updated)
158 self.assertGreater(future, ts.updated)
159 self.assertGreater(future, ts.updated)
160
161 def test_query_filter(self):
162 dt1 = datetime.datetime(2011, 9, 1, 12, 20, 30)
163 dt2 = datetime.datetime(2011, 9, 1, 14, 20, 30)
164 Event.objects.create(dt=dt1)
165 Event.objects.create(dt=dt2)
166 self.assertEqual(Event.objects.filter(dt__gte=dt1).count(), 2)
167 self.assertEqual(Event.objects.filter(dt__gt=dt1).count(), 1)
168 self.assertEqual(Event.objects.filter(dt__gte=dt2).count(), 1)
169 self.assertEqual(Event.objects.filter(dt__gt=dt2).count(), 0)
170
171 def test_query_datetime_lookups(self):
172 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0))
173 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0))
174 self.assertEqual(Event.objects.filter(dt__year=2011).count(), 2)
175 self.assertEqual(Event.objects.filter(dt__month=1).count(), 2)
176 self.assertEqual(Event.objects.filter(dt__day=1).count(), 2)
177 self.assertEqual(Event.objects.filter(dt__week_day=7).count(), 2)
178 self.assertEqual(Event.objects.filter(dt__iso_week_day=6).count(), 2)
179 self.assertEqual(Event.objects.filter(dt__hour=1).count(), 1)
180 self.assertEqual(Event.objects.filter(dt__minute=30).count(), 2)
181 self.assertEqual(Event.objects.filter(dt__second=0).count(), 2)
182
183 def test_query_aggregation(self):
184 # Only min and max make sense for datetimes.
185 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20))
186 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30))
187 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40))
188 result = Event.objects.aggregate(Min("dt"), Max("dt"))
189 self.assertEqual(
190 result,
191 {
192 "dt__min": datetime.datetime(2011, 9, 1, 3, 20, 40),
193 "dt__max": datetime.datetime(2011, 9, 1, 23, 20, 20),
194 },
195 )
196
197 def test_query_annotation(self):
198 # Only min and max make sense for datetimes.
199 morning = Session.objects.create(name="morning")
200 afternoon = Session.objects.create(name="afternoon")
201 SessionEvent.objects.create(
202 dt=datetime.datetime(2011, 9, 1, 23, 20, 20), session=afternoon
203 )
204 SessionEvent.objects.create(
205 dt=datetime.datetime(2011, 9, 1, 13, 20, 30), session=afternoon
206 )
207 SessionEvent.objects.create(
208 dt=datetime.datetime(2011, 9, 1, 3, 20, 40), session=morning
209 )
210 morning_min_dt = datetime.datetime(2011, 9, 1, 3, 20, 40)
211 afternoon_min_dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
212 self.assertQuerySetEqual(
213 Session.objects.annotate(dt=Min("events__dt")).order_by("dt"),
214 [morning_min_dt, afternoon_min_dt],
215 transform=lambda d: d.dt,
216 )
217 self.assertQuerySetEqual(
218 Session.objects.annotate(dt=Min("events__dt")).filter(
219 dt__lt=afternoon_min_dt
220 ),
221 [morning_min_dt],
222 transform=lambda d: d.dt,
223 )
224 self.assertQuerySetEqual(
225 Session.objects.annotate(dt=Min("events__dt")).filter(
226 dt__gte=afternoon_min_dt
227 ),
228 [afternoon_min_dt],
229 transform=lambda d: d.dt,
230 )
231
232 def test_query_datetimes(self):
233 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0))
234 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0))
235 self.assertSequenceEqual(
236 Event.objects.datetimes("dt", "year"),
237 [datetime.datetime(2011, 1, 1, 0, 0, 0)],
238 )
239 self.assertSequenceEqual(
240 Event.objects.datetimes("dt", "month"),
241 [datetime.datetime(2011, 1, 1, 0, 0, 0)],
242 )
243 self.assertSequenceEqual(
244 Event.objects.datetimes("dt", "day"),
245 [datetime.datetime(2011, 1, 1, 0, 0, 0)],
246 )
247 self.assertSequenceEqual(
248 Event.objects.datetimes("dt", "hour"),
249 [
250 datetime.datetime(2011, 1, 1, 1, 0, 0),
251 datetime.datetime(2011, 1, 1, 4, 0, 0),
252 ],
253 )
254 self.assertSequenceEqual(
255 Event.objects.datetimes("dt", "minute"),
256 [
257 datetime.datetime(2011, 1, 1, 1, 30, 0),
258 datetime.datetime(2011, 1, 1, 4, 30, 0),
259 ],
260 )
261 self.assertSequenceEqual(
262 Event.objects.datetimes("dt", "second"),
263 [
264 datetime.datetime(2011, 1, 1, 1, 30, 0),
265 datetime.datetime(2011, 1, 1, 4, 30, 0),
266 ],
267 )
268
269 def test_raw_sql(self):
270 # Regression test for #17755
271 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
272 event = Event.objects.create(dt=dt)
273 self.assertEqual(
274 list(
275 Event.objects.raw("SELECT * FROM timezones_event WHERE dt = %s", [dt])
276 ),
277 [event],
278 )
279
280 def test_cursor_execute_accepts_naive_datetime(self):
281 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
282 with connection.cursor() as cursor:
283 cursor.execute("INSERT INTO timezones_event (dt) VALUES (%s)", [dt])
284 event = Event.objects.get()
285 self.assertEqual(event.dt, dt)
286
287 def test_cursor_execute_returns_naive_datetime(self):
288 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
289 Event.objects.create(dt=dt)
290 with connection.cursor() as cursor:
291 cursor.execute("SELECT dt FROM timezones_event WHERE dt = %s", [dt])
292 self.assertEqual(cursor.fetchall()[0][0], dt)
293
294 def test_filter_date_field_with_aware_datetime(self):
295 # Regression test for #17742
296 day = datetime.date(2011, 9, 1)
297 AllDayEvent.objects.create(day=day)
298 # This is 2011-09-02T01:30:00+03:00 in EAT
299 dt = datetime.datetime(2011, 9, 1, 22, 30, 0, tzinfo=UTC)
300 self.assertTrue(AllDayEvent.objects.filter(day__gte=dt).exists())
301
302
303 @override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=True)
304 class NewDatabaseTests(TestCase):
305 naive_warning = "DateTimeField Event.dt received a naive datetime"
306
307 @skipIfDBFeature("supports_timezones")
308 def test_aware_time_unsupported(self):
309 t = datetime.time(13, 20, 30, tzinfo=EAT)
310 msg = "backend does not support timezone-aware times."
311 with self.assertRaisesMessage(ValueError, msg):
312 DailyEvent.objects.create(time=t)
313
314 @requires_tz_support
315 def test_naive_datetime(self):
316 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
317 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
318 Event.objects.create(dt=dt)
319 event = Event.objects.get()
320 # naive datetimes are interpreted in local time
321 self.assertEqual(event.dt, dt.replace(tzinfo=EAT))
322
323 @requires_tz_support
324 def test_datetime_from_date(self):
325 dt = datetime.date(2011, 9, 1)
326 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
327 Event.objects.create(dt=dt)
328 event = Event.objects.get()
329 self.assertEqual(event.dt, datetime.datetime(2011, 9, 1, tzinfo=EAT))
330
331 @requires_tz_support
332 def test_filter_unbound_datetime_with_naive_date(self):
333 dt = datetime.date(2011, 9, 1)
334 msg = "DateTimeField (unbound) received a naive datetime"
335 with self.assertWarnsMessage(RuntimeWarning, msg):
336 Event.objects.annotate(unbound_datetime=Now()).filter(unbound_datetime=dt)
337
338 @requires_tz_support
339 def test_naive_datetime_with_microsecond(self):
340 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060)
341 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
342 Event.objects.create(dt=dt)
343 event = Event.objects.get()
344 # naive datetimes are interpreted in local time
345 self.assertEqual(event.dt, dt.replace(tzinfo=EAT))
346
347 def test_aware_datetime_in_local_timezone(self):
348 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
349 Event.objects.create(dt=dt)
350 event = Event.objects.get()
351 self.assertEqual(event.dt, dt)
352
353 def test_aware_datetime_in_local_timezone_with_microsecond(self):
354 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060, tzinfo=EAT)
355 Event.objects.create(dt=dt)
356 event = Event.objects.get()
357 self.assertEqual(event.dt, dt)
358
359 def test_aware_datetime_in_utc(self):
360 dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
361 Event.objects.create(dt=dt)
362 event = Event.objects.get()
363 self.assertEqual(event.dt, dt)
364
365 def test_aware_datetime_in_other_timezone(self):
366 dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT)
367 Event.objects.create(dt=dt)
368 event = Event.objects.get()
369 self.assertEqual(event.dt, dt)
370
371 def test_auto_now_and_auto_now_add(self):
372 now = timezone.now()
373 past = now - datetime.timedelta(seconds=2)
374 future = now + datetime.timedelta(seconds=2)
375 Timestamp.objects.create()
376 ts = Timestamp.objects.get()
377 self.assertLess(past, ts.created)
378 self.assertLess(past, ts.updated)
379 self.assertGreater(future, ts.updated)
380 self.assertGreater(future, ts.updated)
381
382 def test_query_filter(self):
383 dt1 = datetime.datetime(2011, 9, 1, 12, 20, 30, tzinfo=EAT)
384 dt2 = datetime.datetime(2011, 9, 1, 14, 20, 30, tzinfo=EAT)
385 Event.objects.create(dt=dt1)
386 Event.objects.create(dt=dt2)
387 self.assertEqual(Event.objects.filter(dt__gte=dt1).count(), 2)
388 self.assertEqual(Event.objects.filter(dt__gt=dt1).count(), 1)
389 self.assertEqual(Event.objects.filter(dt__gte=dt2).count(), 1)
390 self.assertEqual(Event.objects.filter(dt__gt=dt2).count(), 0)
391
392 def test_query_filter_with_timezones(self):
393 tz = zoneinfo.ZoneInfo("Europe/Paris")
394 dt = datetime.datetime(2011, 9, 1, 12, 20, 30, tzinfo=tz)
395 Event.objects.create(dt=dt)
396 next = dt + datetime.timedelta(seconds=3)
397 prev = dt - datetime.timedelta(seconds=3)
398 self.assertEqual(Event.objects.filter(dt__exact=dt).count(), 1)
399 self.assertEqual(Event.objects.filter(dt__exact=next).count(), 0)
400 self.assertEqual(Event.objects.filter(dt__in=(prev, next)).count(), 0)
401 self.assertEqual(Event.objects.filter(dt__in=(prev, dt, next)).count(), 1)
402 self.assertEqual(Event.objects.filter(dt__range=(prev, next)).count(), 1)
403
404 def test_query_convert_timezones(self):
405 # Connection timezone is equal to the current timezone, datetime
406 # shouldn't be converted.
407 with override_database_connection_timezone("Africa/Nairobi"):
408 event_datetime = datetime.datetime(2016, 1, 2, 23, 10, 11, 123, tzinfo=EAT)
409 event = Event.objects.create(dt=event_datetime)
410 self.assertEqual(
411 Event.objects.filter(dt__date=event_datetime.date()).first(), event
412 )
413 # Connection timezone is not equal to the current timezone, datetime
414 # should be converted (-4h).
415 with override_database_connection_timezone("Asia/Bangkok"):
416 event_datetime = datetime.datetime(2016, 1, 2, 3, 10, 11, tzinfo=ICT)
417 event = Event.objects.create(dt=event_datetime)
418 self.assertEqual(
419 Event.objects.filter(dt__date=datetime.date(2016, 1, 1)).first(), event
420 )
421
422 @requires_tz_support
423 def test_query_filter_with_naive_datetime(self):
424 dt = datetime.datetime(2011, 9, 1, 12, 20, 30, tzinfo=EAT)
425 Event.objects.create(dt=dt)
426 dt = dt.replace(tzinfo=None)
427 # naive datetimes are interpreted in local time
428 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
429 self.assertEqual(Event.objects.filter(dt__exact=dt).count(), 1)
430 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
431 self.assertEqual(Event.objects.filter(dt__lte=dt).count(), 1)
432 with self.assertWarnsMessage(RuntimeWarning, self.naive_warning):
433 self.assertEqual(Event.objects.filter(dt__gt=dt).count(), 0)
434
435 @skipUnlessDBFeature("has_zoneinfo_database")
436 def test_query_datetime_lookups(self):
437 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
438 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
439 self.assertEqual(Event.objects.filter(dt__year=2011).count(), 2)
440 self.assertEqual(Event.objects.filter(dt__month=1).count(), 2)
441 self.assertEqual(Event.objects.filter(dt__day=1).count(), 2)
442 self.assertEqual(Event.objects.filter(dt__week_day=7).count(), 2)
443 self.assertEqual(Event.objects.filter(dt__iso_week_day=6).count(), 2)
444 self.assertEqual(Event.objects.filter(dt__hour=1).count(), 1)
445 self.assertEqual(Event.objects.filter(dt__minute=30).count(), 2)
446 self.assertEqual(Event.objects.filter(dt__second=0).count(), 2)
447
448 @skipUnlessDBFeature("has_zoneinfo_database")
449 def test_query_datetime_lookups_in_other_timezone(self):
450 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
451 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
452 with timezone.override(UTC):
453 # These two dates fall in the same day in EAT, but in different days,
454 # years and months in UTC.
455 self.assertEqual(Event.objects.filter(dt__year=2011).count(), 1)
456 self.assertEqual(Event.objects.filter(dt__month=1).count(), 1)
457 self.assertEqual(Event.objects.filter(dt__day=1).count(), 1)
458 self.assertEqual(Event.objects.filter(dt__week_day=7).count(), 1)
459 self.assertEqual(Event.objects.filter(dt__iso_week_day=6).count(), 1)
460 self.assertEqual(Event.objects.filter(dt__hour=22).count(), 1)
461 self.assertEqual(Event.objects.filter(dt__minute=30).count(), 2)
462 self.assertEqual(Event.objects.filter(dt__second=0).count(), 2)
463
464 def test_query_aggregation(self):
465 # Only min and max make sense for datetimes.
466 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT))
467 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT))
468 Event.objects.create(dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT))
469 result = Event.objects.aggregate(Min("dt"), Max("dt"))
470 self.assertEqual(
471 result,
472 {
473 "dt__min": datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT),
474 "dt__max": datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT),
475 },
476 )
477
478 def test_query_annotation(self):
479 # Only min and max make sense for datetimes.
480 morning = Session.objects.create(name="morning")
481 afternoon = Session.objects.create(name="afternoon")
482 SessionEvent.objects.create(
483 dt=datetime.datetime(2011, 9, 1, 23, 20, 20, tzinfo=EAT), session=afternoon
484 )
485 SessionEvent.objects.create(
486 dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), session=afternoon
487 )
488 SessionEvent.objects.create(
489 dt=datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT), session=morning
490 )
491 morning_min_dt = datetime.datetime(2011, 9, 1, 3, 20, 40, tzinfo=EAT)
492 afternoon_min_dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
493 self.assertQuerySetEqual(
494 Session.objects.annotate(dt=Min("events__dt")).order_by("dt"),
495 [morning_min_dt, afternoon_min_dt],
496 transform=lambda d: d.dt,
497 )
498 self.assertQuerySetEqual(
499 Session.objects.annotate(dt=Min("events__dt")).filter(
500 dt__lt=afternoon_min_dt
501 ),
502 [morning_min_dt],
503 transform=lambda d: d.dt,
504 )
505 self.assertQuerySetEqual(
506 Session.objects.annotate(dt=Min("events__dt")).filter(
507 dt__gte=afternoon_min_dt
508 ),
509 [afternoon_min_dt],
510 transform=lambda d: d.dt,
511 )
512
513 @skipUnlessDBFeature("has_zoneinfo_database")
514 def test_query_datetimes(self):
515 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
516 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
517 self.assertSequenceEqual(
518 Event.objects.datetimes("dt", "year"),
519 [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
520 )
521 self.assertSequenceEqual(
522 Event.objects.datetimes("dt", "month"),
523 [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
524 )
525 self.assertSequenceEqual(
526 Event.objects.datetimes("dt", "day"),
527 [datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=EAT)],
528 )
529 self.assertSequenceEqual(
530 Event.objects.datetimes("dt", "hour"),
531 [
532 datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=EAT),
533 datetime.datetime(2011, 1, 1, 4, 0, 0, tzinfo=EAT),
534 ],
535 )
536 self.assertSequenceEqual(
537 Event.objects.datetimes("dt", "minute"),
538 [
539 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
540 datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT),
541 ],
542 )
543 self.assertSequenceEqual(
544 Event.objects.datetimes("dt", "second"),
545 [
546 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT),
547 datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT),
548 ],
549 )
550
551 @skipUnlessDBFeature("has_zoneinfo_database")
552 def test_query_datetimes_in_other_timezone(self):
553 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=EAT))
554 Event.objects.create(dt=datetime.datetime(2011, 1, 1, 4, 30, 0, tzinfo=EAT))
555 with timezone.override(UTC):
556 self.assertSequenceEqual(
557 Event.objects.datetimes("dt", "year"),
558 [
559 datetime.datetime(2010, 1, 1, 0, 0, 0, tzinfo=UTC),
560 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
561 ],
562 )
563 self.assertSequenceEqual(
564 Event.objects.datetimes("dt", "month"),
565 [
566 datetime.datetime(2010, 12, 1, 0, 0, 0, tzinfo=UTC),
567 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
568 ],
569 )
570 self.assertSequenceEqual(
571 Event.objects.datetimes("dt", "day"),
572 [
573 datetime.datetime(2010, 12, 31, 0, 0, 0, tzinfo=UTC),
574 datetime.datetime(2011, 1, 1, 0, 0, 0, tzinfo=UTC),
575 ],
576 )
577 self.assertSequenceEqual(
578 Event.objects.datetimes("dt", "hour"),
579 [
580 datetime.datetime(2010, 12, 31, 22, 0, 0, tzinfo=UTC),
581 datetime.datetime(2011, 1, 1, 1, 0, 0, tzinfo=UTC),
582 ],
583 )
584 self.assertSequenceEqual(
585 Event.objects.datetimes("dt", "minute"),
586 [
587 datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
588 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC),
589 ],
590 )
591 self.assertSequenceEqual(
592 Event.objects.datetimes("dt", "second"),
593 [
594 datetime.datetime(2010, 12, 31, 22, 30, 0, tzinfo=UTC),
595 datetime.datetime(2011, 1, 1, 1, 30, 0, tzinfo=UTC),
596 ],
597 )
598
599 def test_raw_sql(self):
600 # Regression test for #17755
601 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
602 event = Event.objects.create(dt=dt)
603 self.assertSequenceEqual(
604 list(
605 Event.objects.raw("SELECT * FROM timezones_event WHERE dt = %s", [dt])
606 ),
607 [event],
608 )
609
610 @skipUnlessDBFeature("supports_timezones")
611 def test_cursor_execute_accepts_aware_datetime(self):
612 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
613 with connection.cursor() as cursor:
614 cursor.execute("INSERT INTO timezones_event (dt) VALUES (%s)", [dt])
615 event = Event.objects.get()
616 self.assertEqual(event.dt, dt)
617
618 @skipIfDBFeature("supports_timezones")
619 def test_cursor_execute_accepts_naive_datetime(self):
620 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
621 utc_naive_dt = timezone.make_naive(dt, datetime.timezone.utc)
622 with connection.cursor() as cursor:
623 cursor.execute(
624 "INSERT INTO timezones_event (dt) VALUES (%s)", [utc_naive_dt]
625 )
626 event = Event.objects.get()
627 self.assertEqual(event.dt, dt)
628
629 @skipUnlessDBFeature("supports_timezones")
630 def test_cursor_execute_returns_aware_datetime(self):
631 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
632 Event.objects.create(dt=dt)
633 with connection.cursor() as cursor:
634 cursor.execute("SELECT dt FROM timezones_event WHERE dt = %s", [dt])
635 self.assertEqual(cursor.fetchall()[0][0], dt)
636
637 @skipIfDBFeature("supports_timezones")
638 def test_cursor_execute_returns_naive_datetime(self):
639 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
640 utc_naive_dt = timezone.make_naive(dt, datetime.timezone.utc)
641 Event.objects.create(dt=dt)
642 with connection.cursor() as cursor:
643 cursor.execute(
644 "SELECT dt FROM timezones_event WHERE dt = %s", [utc_naive_dt]
645 )
646 self.assertEqual(cursor.fetchall()[0][0], utc_naive_dt)
647
648 @skipUnlessDBFeature("supports_timezones")
649 def test_cursor_explicit_time_zone(self):
650 with override_database_connection_timezone("Europe/Paris"):
651 with connection.cursor() as cursor:
652 cursor.execute("SELECT CURRENT_TIMESTAMP")
653 now = cursor.fetchone()[0]
654 self.assertEqual(str(now.tzinfo), "Europe/Paris")
655
656 @requires_tz_support
657 def test_filter_date_field_with_aware_datetime(self):
658 # Regression test for #17742
659 day = datetime.date(2011, 9, 1)
660 AllDayEvent.objects.create(day=day)
661 # This is 2011-09-02T01:30:00+03:00 in EAT
662 dt = datetime.datetime(2011, 9, 1, 22, 30, 0, tzinfo=UTC)
663 self.assertFalse(AllDayEvent.objects.filter(day__gte=dt).exists())
664
665 def test_null_datetime(self):
666 # Regression test for #17294
667 e = MaybeEvent.objects.create()
668 self.assertIsNone(e.dt)
669
670 def test_update_with_timedelta(self):
671 initial_dt = timezone.now().replace(microsecond=0)
672 event = Event.objects.create(dt=initial_dt)
673 Event.objects.update(dt=F("dt") + timedelta(hours=2))
674 event.refresh_from_db()
675 self.assertEqual(event.dt, initial_dt + timedelta(hours=2))
676
677
678 @override_settings(TIME_ZONE="Africa/Nairobi", USE_TZ=True)
679 class ForcedTimeZoneDatabaseTests(TransactionTestCase):
680 """
681 Test the TIME_ZONE database configuration parameter.
682
683 Since this involves reading and writing to the same database through two
684 connections, this is a TransactionTestCase.
685 """
686
687 available_apps = ["timezones"]
688
689 @classmethod
690 def setUpClass(cls):
691 # @skipIfDBFeature and @skipUnlessDBFeature cannot be chained. The
692 # outermost takes precedence. Handle skipping manually instead.
693 if connection.features.supports_timezones:
694 raise SkipTest("Database has feature(s) supports_timezones")
695 if not connection.features.test_db_allows_multiple_connections:
696 raise SkipTest(
697 "Database doesn't support feature(s): "
698 "test_db_allows_multiple_connections"
699 )
700
701 super().setUpClass()
702
703 def test_read_datetime(self):
704 fake_dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=UTC)
705 Event.objects.create(dt=fake_dt)
706
707 with override_database_connection_timezone("Asia/Bangkok"):
708 event = Event.objects.get()
709 dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
710 self.assertEqual(event.dt, dt)
711
712 def test_write_datetime(self):
713 dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
714 with override_database_connection_timezone("Asia/Bangkok"):
715 Event.objects.create(dt=dt)
716
717 event = Event.objects.get()
718 fake_dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=UTC)
719 self.assertEqual(event.dt, fake_dt)
720
721
722 @override_settings(TIME_ZONE="Africa/Nairobi")
723 class SerializationTests(SimpleTestCase):
724 # Backend-specific notes:
725 # - JSON supports only milliseconds, microseconds will be truncated.
726 # - PyYAML dumps the UTC offset correctly for timezone-aware datetimes.
727 # When PyYAML < 5.3 loads this representation, it subtracts the offset
728 # and returns a naive datetime object in UTC. PyYAML 5.3+ loads timezones
729 # correctly.
730 # Tests are adapted to take these quirks into account.
731
732 def assert_python_contains_datetime(self, objects, dt):
733 self.assertEqual(objects[0]["fields"]["dt"], dt)
734
735 def assert_json_contains_datetime(self, json, dt):
736 self.assertIn('"fields": {"dt": "%s"}' % dt, json)
737
738 def assert_xml_contains_datetime(self, xml, dt):
739 field = parseString(xml).getElementsByTagName("field")[0]
740 self.assertXMLEqual(field.childNodes[0].wholeText, dt)
741
742 def assert_yaml_contains_datetime(self, yaml, dt):
743 # Depending on the yaml dumper, '!timestamp' might be absent
744 self.assertRegex(yaml, r"\n fields: {dt: !(!timestamp)? '%s'}" % re.escape(dt))
745
746 def test_naive_datetime(self):
747 dt = datetime.datetime(2011, 9, 1, 13, 20, 30)
748
749 data = serializers.serialize("python", [Event(dt=dt)])
750 self.assert_python_contains_datetime(data, dt)
751 obj = next(serializers.deserialize("python", data)).object
752 self.assertEqual(obj.dt, dt)
753
754 data = serializers.serialize("json", [Event(dt=dt)])
755 self.assert_json_contains_datetime(data, "2011-09-01T13:20:30")
756 obj = next(serializers.deserialize("json", data)).object
757 self.assertEqual(obj.dt, dt)
758
759 data = serializers.serialize("xml", [Event(dt=dt)])
760 self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30")
761 obj = next(serializers.deserialize("xml", data)).object
762 self.assertEqual(obj.dt, dt)
763
764 if not isinstance(
765 serializers.get_serializer("yaml"), serializers.BadSerializer
766 ):
767 data = serializers.serialize(
768 "yaml", [Event(dt=dt)], default_flow_style=None
769 )
770 self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30")
771 obj = next(serializers.deserialize("yaml", data)).object
772 self.assertEqual(obj.dt, dt)
773
774 def test_naive_datetime_with_microsecond(self):
775 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, 405060)
776
777 data = serializers.serialize("python", [Event(dt=dt)])
778 self.assert_python_contains_datetime(data, dt)
779 obj = next(serializers.deserialize("python", data)).object
780 self.assertEqual(obj.dt, dt)
781
782 data = serializers.serialize("json", [Event(dt=dt)])
783 self.assert_json_contains_datetime(data, "2011-09-01T13:20:30.405")
784 obj = next(serializers.deserialize("json", data)).object
785 self.assertEqual(obj.dt, dt.replace(microsecond=405000))
786
787 data = serializers.serialize("xml", [Event(dt=dt)])
788 self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30.405060")
789 obj = next(serializers.deserialize("xml", data)).object
790 self.assertEqual(obj.dt, dt)
791
792 if not isinstance(
793 serializers.get_serializer("yaml"), serializers.BadSerializer
794 ):
795 data = serializers.serialize(
796 "yaml", [Event(dt=dt)], default_flow_style=None
797 )
798 self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30.405060")
799 obj = next(serializers.deserialize("yaml", data)).object
800 self.assertEqual(obj.dt, dt)
801
802 def test_aware_datetime_with_microsecond(self):
803 dt = datetime.datetime(2011, 9, 1, 17, 20, 30, 405060, tzinfo=ICT)
804
805 data = serializers.serialize("python", [Event(dt=dt)])
806 self.assert_python_contains_datetime(data, dt)
807 obj = next(serializers.deserialize("python", data)).object
808 self.assertEqual(obj.dt, dt)
809
810 data = serializers.serialize("json", [Event(dt=dt)])
811 self.assert_json_contains_datetime(data, "2011-09-01T17:20:30.405+07:00")
812 obj = next(serializers.deserialize("json", data)).object
813 self.assertEqual(obj.dt, dt.replace(microsecond=405000))
814
815 data = serializers.serialize("xml", [Event(dt=dt)])
816 self.assert_xml_contains_datetime(data, "2011-09-01T17:20:30.405060+07:00")
817 obj = next(serializers.deserialize("xml", data)).object
818 self.assertEqual(obj.dt, dt)
819
820 if not isinstance(
821 serializers.get_serializer("yaml"), serializers.BadSerializer
822 ):
823 data = serializers.serialize(
824 "yaml", [Event(dt=dt)], default_flow_style=None
825 )
826 self.assert_yaml_contains_datetime(data, "2011-09-01 17:20:30.405060+07:00")
827 obj = next(serializers.deserialize("yaml", data)).object
828 if HAS_YAML and yaml.__version__ < "5.3":
829 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
830 else:
831 self.assertEqual(obj.dt, dt)
832
833 def test_aware_datetime_in_utc(self):
834 dt = datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
835
836 data = serializers.serialize("python", [Event(dt=dt)])
837 self.assert_python_contains_datetime(data, dt)
838 obj = next(serializers.deserialize("python", data)).object
839 self.assertEqual(obj.dt, dt)
840
841 data = serializers.serialize("json", [Event(dt=dt)])
842 self.assert_json_contains_datetime(data, "2011-09-01T10:20:30Z")
843 obj = next(serializers.deserialize("json", data)).object
844 self.assertEqual(obj.dt, dt)
845
846 data = serializers.serialize("xml", [Event(dt=dt)])
847 self.assert_xml_contains_datetime(data, "2011-09-01T10:20:30+00:00")
848 obj = next(serializers.deserialize("xml", data)).object
849 self.assertEqual(obj.dt, dt)
850
851 if not isinstance(
852 serializers.get_serializer("yaml"), serializers.BadSerializer
853 ):
854 data = serializers.serialize(
855 "yaml", [Event(dt=dt)], default_flow_style=None
856 )
857 self.assert_yaml_contains_datetime(data, "2011-09-01 10:20:30+00:00")
858 obj = next(serializers.deserialize("yaml", data)).object
859 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
860
861 def test_aware_datetime_in_local_timezone(self):
862 dt = datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)
863
864 data = serializers.serialize("python", [Event(dt=dt)])
865 self.assert_python_contains_datetime(data, dt)
866 obj = next(serializers.deserialize("python", data)).object
867 self.assertEqual(obj.dt, dt)
868
869 data = serializers.serialize("json", [Event(dt=dt)])
870 self.assert_json_contains_datetime(data, "2011-09-01T13:20:30+03:00")
871 obj = next(serializers.deserialize("json", data)).object
872 self.assertEqual(obj.dt, dt)
873
874 data = serializers.serialize("xml", [Event(dt=dt)])
875 self.assert_xml_contains_datetime(data, "2011-09-01T13:20:30+03:00")
876 obj = next(serializers.deserialize("xml", data)).object
877 self.assertEqual(obj.dt, dt)
878
879 if not isinstance(
880 serializers.get_serializer("yaml"), serializers.BadSerializer
881 ):
882 data = serializers.serialize(
883 "yaml", [Event(dt=dt)], default_flow_style=None
884 )
885 self.assert_yaml_contains_datetime(data, "2011-09-01 13:20:30+03:00")
886 obj = next(serializers.deserialize("yaml", data)).object
887 if HAS_YAML and yaml.__version__ < "5.3":
888 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
889 else:
890 self.assertEqual(obj.dt, dt)
891
892 def test_aware_datetime_in_other_timezone(self):
893 dt = datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT)
894
895 data = serializers.serialize("python", [Event(dt=dt)])
896 self.assert_python_contains_datetime(data, dt)
897 obj = next(serializers.deserialize("python", data)).object
898 self.assertEqual(obj.dt, dt)
899
900 data = serializers.serialize("json", [Event(dt=dt)])
901 self.assert_json_contains_datetime(data, "2011-09-01T17:20:30+07:00")
902 obj = next(serializers.deserialize("json", data)).object
903 self.assertEqual(obj.dt, dt)
904
905 data = serializers.serialize("xml", [Event(dt=dt)])
906 self.assert_xml_contains_datetime(data, "2011-09-01T17:20:30+07:00")
907 obj = next(serializers.deserialize("xml", data)).object
908 self.assertEqual(obj.dt, dt)
909
910 if not isinstance(
911 serializers.get_serializer("yaml"), serializers.BadSerializer
912 ):
913 data = serializers.serialize(
914 "yaml", [Event(dt=dt)], default_flow_style=None
915 )
916 self.assert_yaml_contains_datetime(data, "2011-09-01 17:20:30+07:00")
917 obj = next(serializers.deserialize("yaml", data)).object
918 if HAS_YAML and yaml.__version__ < "5.3":
919 self.assertEqual(obj.dt.replace(tzinfo=UTC), dt)
920 else:
921 self.assertEqual(obj.dt, dt)
922
923
924 @translation.override(None)
925 @override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=True)
926 class TemplateTests(SimpleTestCase):
927 @requires_tz_support
928 def test_localtime_templatetag_and_filters(self):
929 """
930 Test the {% localtime %} templatetag and related filters.
931 """
932 datetimes = {
933 "utc": datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
934 "eat": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
935 "ict": datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT),
936 "naive": datetime.datetime(2011, 9, 1, 13, 20, 30),
937 }
938 templates = {
939 "notag": Template(
940 "{% load tz %}"
941 "{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:ICT }}"
942 ),
943 "noarg": Template(
944 "{% load tz %}{% localtime %}{{ dt }}|{{ dt|localtime }}|"
945 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
946 ),
947 "on": Template(
948 "{% load tz %}{% localtime on %}{{ dt }}|{{ dt|localtime }}|"
949 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
950 ),
951 "off": Template(
952 "{% load tz %}{% localtime off %}{{ dt }}|{{ dt|localtime }}|"
953 "{{ dt|utc }}|{{ dt|timezone:ICT }}{% endlocaltime %}"
954 ),
955 }
956
957 # Transform a list of keys in 'datetimes' to the expected template
958 # output. This makes the definition of 'results' more readable.
959 def t(*result):
960 return "|".join(datetimes[key].isoformat() for key in result)
961
962 # Results for USE_TZ = True
963
964 results = {
965 "utc": {
966 "notag": t("eat", "eat", "utc", "ict"),
967 "noarg": t("eat", "eat", "utc", "ict"),
968 "on": t("eat", "eat", "utc", "ict"),
969 "off": t("utc", "eat", "utc", "ict"),
970 },
971 "eat": {
972 "notag": t("eat", "eat", "utc", "ict"),
973 "noarg": t("eat", "eat", "utc", "ict"),
974 "on": t("eat", "eat", "utc", "ict"),
975 "off": t("eat", "eat", "utc", "ict"),
976 },
977 "ict": {
978 "notag": t("eat", "eat", "utc", "ict"),
979 "noarg": t("eat", "eat", "utc", "ict"),
980 "on": t("eat", "eat", "utc", "ict"),
981 "off": t("ict", "eat", "utc", "ict"),
982 },
983 "naive": {
984 "notag": t("naive", "eat", "utc", "ict"),
985 "noarg": t("naive", "eat", "utc", "ict"),
986 "on": t("naive", "eat", "utc", "ict"),
987 "off": t("naive", "eat", "utc", "ict"),
988 },
989 }
990
991 for k1, dt in datetimes.items():
992 for k2, tpl in templates.items():
993 ctx = Context({"dt": dt, "ICT": ICT})
994 actual = tpl.render(ctx)
995 expected = results[k1][k2]
996 self.assertEqual(
997 actual, expected, "%s / %s: %r != %r" % (k1, k2, actual, expected)
998 )
999
1000 # Changes for USE_TZ = False
1001
1002 results["utc"]["notag"] = t("utc", "eat", "utc", "ict")
1003 results["ict"]["notag"] = t("ict", "eat", "utc", "ict")
1004
1005 with self.settings(USE_TZ=False):
1006 for k1, dt in datetimes.items():
1007 for k2, tpl in templates.items():
1008 ctx = Context({"dt": dt, "ICT": ICT})
1009 actual = tpl.render(ctx)
1010 expected = results[k1][k2]
1011 self.assertEqual(
1012 actual,
1013 expected,
1014 "%s / %s: %r != %r" % (k1, k2, actual, expected),
1015 )
1016
1017 def test_localtime_filters_with_iana(self):
1018 """
1019 Test the |localtime, |utc, and |timezone filters with iana zones.
1020 """
1021 # Use an IANA timezone as local time
1022 tpl = Template("{% load tz %}{{ dt|localtime }}|{{ dt|utc }}")
1023 ctx = Context({"dt": datetime.datetime(2011, 9, 1, 12, 20, 30)})
1024
1025 with self.settings(TIME_ZONE="Europe/Paris"):
1026 self.assertEqual(
1027 tpl.render(ctx), "2011-09-01T12:20:30+02:00|2011-09-01T10:20:30+00:00"
1028 )
1029
1030 # Use an IANA timezone as argument
1031 tz = zoneinfo.ZoneInfo("Europe/Paris")
1032 tpl = Template("{% load tz %}{{ dt|timezone:tz }}")
1033 ctx = Context(
1034 {
1035 "dt": datetime.datetime(2011, 9, 1, 13, 20, 30),
1036 "tz": tz,
1037 }
1038 )
1039 self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
1040
1041 def test_localtime_templatetag_invalid_argument(self):
1042 with self.assertRaises(TemplateSyntaxError):
1043 Template("{% load tz %}{% localtime foo %}{% endlocaltime %}").render()
1044
1045 def test_localtime_filters_do_not_raise_exceptions(self):
1046 """
1047 Test the |localtime, |utc, and |timezone filters on bad inputs.
1048 """
1049 tpl = Template(
1050 "{% load tz %}{{ dt }}|{{ dt|localtime }}|{{ dt|utc }}|{{ dt|timezone:tz }}"
1051 )
1052 with self.settings(USE_TZ=True):
1053 # bad datetime value
1054 ctx = Context({"dt": None, "tz": ICT})
1055 self.assertEqual(tpl.render(ctx), "None|||")
1056 ctx = Context({"dt": "not a date", "tz": ICT})
1057 self.assertEqual(tpl.render(ctx), "not a date|||")
1058 # bad timezone value
1059 tpl = Template("{% load tz %}{{ dt|timezone:tz }}")
1060 ctx = Context({"dt": datetime.datetime(2011, 9, 1, 13, 20, 30), "tz": None})
1061 self.assertEqual(tpl.render(ctx), "")
1062 ctx = Context(
1063 {"dt": datetime.datetime(2011, 9, 1, 13, 20, 30), "tz": "not a tz"}
1064 )
1065 self.assertEqual(tpl.render(ctx), "")
1066
1067 @requires_tz_support
1068 def test_timezone_templatetag(self):
1069 """
1070 Test the {% timezone %} templatetag.
1071 """
1072 tpl = Template(
1073 "{% load tz %}"
1074 "{{ dt }}|"
1075 "{% timezone tz1 %}"
1076 "{{ dt }}|"
1077 "{% timezone tz2 %}"
1078 "{{ dt }}"
1079 "{% endtimezone %}"
1080 "{% endtimezone %}"
1081 )
1082 ctx = Context(
1083 {
1084 "dt": datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
1085 "tz1": ICT,
1086 "tz2": None,
1087 }
1088 )
1089 self.assertEqual(
1090 tpl.render(ctx),
1091 "2011-09-01T13:20:30+03:00|2011-09-01T17:20:30+07:00|"
1092 "2011-09-01T13:20:30+03:00",
1093 )
1094
1095 def test_timezone_templatetag_with_iana(self):
1096 """
1097 Test the {% timezone %} templatetag with IANA time zone providers.
1098 """
1099 tpl = Template("{% load tz %}{% timezone tz %}{{ dt }}{% endtimezone %}")
1100
1101 # Use a IANA timezone as argument
1102 tz = zoneinfo.ZoneInfo("Europe/Paris")
1103 ctx = Context(
1104 {
1105 "dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
1106 "tz": tz,
1107 }
1108 )
1109 self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
1110
1111 # Use a IANA timezone name as argument
1112 ctx = Context(
1113 {
1114 "dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT),
1115 "tz": "Europe/Paris",
1116 }
1117 )
1118 self.assertEqual(tpl.render(ctx), "2011-09-01T12:20:30+02:00")
1119
1120 @skipIf(sys.platform == "win32", "Windows uses non-standard time zone names")
1121 def test_get_current_timezone_templatetag(self):
1122 """
1123 Test the {% get_current_timezone %} templatetag.
1124 """
1125 tpl = Template(
1126 "{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}"
1127 )
1128
1129 self.assertEqual(tpl.render(Context()), "Africa/Nairobi")
1130 with timezone.override(UTC):
1131 self.assertEqual(tpl.render(Context()), "UTC")
1132
1133 tpl = Template(
1134 "{% load tz %}{% timezone tz %}{% get_current_timezone as time_zone %}"
1135 "{% endtimezone %}{{ time_zone }}"
1136 )
1137
1138 self.assertEqual(tpl.render(Context({"tz": ICT})), "+0700")
1139 with timezone.override(UTC):
1140 self.assertEqual(tpl.render(Context({"tz": ICT})), "+0700")
1141
1142 def test_get_current_timezone_templatetag_with_iana(self):
1143 tpl = Template(
1144 "{% load tz %}{% get_current_timezone as time_zone %}{{ time_zone }}"
1145 )
1146 tz = zoneinfo.ZoneInfo("Europe/Paris")
1147 with timezone.override(tz):
1148 self.assertEqual(tpl.render(Context()), "Europe/Paris")
1149
1150 tpl = Template(
1151 "{% load tz %}{% timezone 'Europe/Paris' %}"
1152 "{% get_current_timezone as time_zone %}{% endtimezone %}"
1153 "{{ time_zone }}"
1154 )
1155 self.assertEqual(tpl.render(Context()), "Europe/Paris")
1156
1157 def test_get_current_timezone_templatetag_invalid_argument(self):
1158 msg = (
1159 "'get_current_timezone' requires 'as variable' (got "
1160 "['get_current_timezone'])"
1161 )
1162 with self.assertRaisesMessage(TemplateSyntaxError, msg):
1163 Template("{% load tz %}{% get_current_timezone %}").render()
1164
1165 @skipIf(sys.platform == "win32", "Windows uses non-standard time zone names")
1166 def test_tz_template_context_processor(self):
1167 """
1168 Test the django.template.context_processors.tz template context processor.
1169 """
1170 tpl = Template("{{ TIME_ZONE }}")
1171 context = Context()
1172 self.assertEqual(tpl.render(context), "")
1173 request_context = RequestContext(
1174 HttpRequest(), processors=[context_processors.tz]
1175 )
1176 self.assertEqual(tpl.render(request_context), "Africa/Nairobi")
1177
1178 @requires_tz_support
1179 def test_date_and_time_template_filters(self):
1180 tpl = Template("{{ dt|date:'Y-m-d' }} at {{ dt|time:'H:i:s' }}")
1181 ctx = Context({"dt": datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
1182 self.assertEqual(tpl.render(ctx), "2011-09-01 at 23:20:20")
1183 with timezone.override(ICT):
1184 self.assertEqual(tpl.render(ctx), "2011-09-02 at 03:20:20")
1185
1186 def test_date_and_time_template_filters_honor_localtime(self):
1187 tpl = Template(
1188 "{% load tz %}{% localtime off %}{{ dt|date:'Y-m-d' }} at "
1189 "{{ dt|time:'H:i:s' }}{% endlocaltime %}"
1190 )
1191 ctx = Context({"dt": datetime.datetime(2011, 9, 1, 20, 20, 20, tzinfo=UTC)})
1192 self.assertEqual(tpl.render(ctx), "2011-09-01 at 20:20:20")
1193 with timezone.override(ICT):
1194 self.assertEqual(tpl.render(ctx), "2011-09-01 at 20:20:20")
1195
1196 @requires_tz_support
1197 def test_now_template_tag_uses_current_time_zone(self):
1198 # Regression for #17343
1199 tpl = Template('{% now "O" %}')
1200 self.assertEqual(tpl.render(Context({})), "+0300")
1201 with timezone.override(ICT):
1202 self.assertEqual(tpl.render(Context({})), "+0700")
1203
1204
1205 @override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=False)
1206 class LegacyFormsTests(TestCase):
1207 def test_form(self):
1208 form = EventForm({"dt": "2011-09-01 13:20:30"})
1209 self.assertTrue(form.is_valid())
1210 self.assertEqual(
1211 form.cleaned_data["dt"], datetime.datetime(2011, 9, 1, 13, 20, 30)
1212 )
1213
1214 def test_form_with_non_existent_time(self):
1215 form = EventForm({"dt": "2011-03-27 02:30:00"})
1216 tz = zoneinfo.ZoneInfo("Europe/Paris")
1217 with timezone.override(tz):
1218 # This is a bug.
1219 self.assertTrue(form.is_valid())
1220 self.assertEqual(
1221 form.cleaned_data["dt"],
1222 datetime.datetime(2011, 3, 27, 2, 30, 0),
1223 )
1224
1225 def test_form_with_ambiguous_time(self):
1226 form = EventForm({"dt": "2011-10-30 02:30:00"})
1227 tz = zoneinfo.ZoneInfo("Europe/Paris")
1228 with timezone.override(tz):
1229 # This is a bug.
1230 self.assertTrue(form.is_valid())
1231 self.assertEqual(
1232 form.cleaned_data["dt"],
1233 datetime.datetime(2011, 10, 30, 2, 30, 0),
1234 )
1235
1236 def test_split_form(self):
1237 form = EventSplitForm({"dt_0": "2011-09-01", "dt_1": "13:20:30"})
1238 self.assertTrue(form.is_valid())
1239 self.assertEqual(
1240 form.cleaned_data["dt"], datetime.datetime(2011, 9, 1, 13, 20, 30)
1241 )
1242
1243 def test_model_form(self):
1244 EventModelForm({"dt": "2011-09-01 13:20:30"}).save()
1245 e = Event.objects.get()
1246 self.assertEqual(e.dt, datetime.datetime(2011, 9, 1, 13, 20, 30))
1247
1248
1249 @override_settings(DATETIME_FORMAT="c", TIME_ZONE="Africa/Nairobi", USE_TZ=True)
1250 class NewFormsTests(TestCase):
1251 @requires_tz_support
1252 def test_form(self):
1253 form = EventForm({"dt": "2011-09-01 13:20:30"})
1254 self.assertTrue(form.is_valid())
1255 self.assertEqual(
1256 form.cleaned_data["dt"],
1257 datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
1258 )
1259
1260 def test_form_with_other_timezone(self):
1261 form = EventForm({"dt": "2011-09-01 17:20:30"})
1262 with timezone.override(ICT):
1263 self.assertTrue(form.is_valid())
1264 self.assertEqual(
1265 form.cleaned_data["dt"],
1266 datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
1267 )
1268
1269 def test_form_with_non_existent_time(self):
1270 tz = zoneinfo.ZoneInfo("Europe/Paris")
1271 with timezone.override(tz):
1272 form = EventForm({"dt": "2011-03-27 02:30:00"})
1273 self.assertFalse(form.is_valid())
1274 self.assertEqual(
1275 form.errors["dt"],
1276 [
1277 "2011-03-27 02:30:00 couldn’t be interpreted in time zone "
1278 "Europe/Paris; it may be ambiguous or it may not exist."
1279 ],
1280 )
1281
1282 def test_form_with_ambiguous_time(self):
1283 tz = zoneinfo.ZoneInfo("Europe/Paris")
1284 with timezone.override(tz):
1285 form = EventForm({"dt": "2011-10-30 02:30:00"})
1286 self.assertFalse(form.is_valid())
1287 self.assertEqual(
1288 form.errors["dt"],
1289 [
1290 "2011-10-30 02:30:00 couldn’t be interpreted in time zone "
1291 "Europe/Paris; it may be ambiguous or it may not exist."
1292 ],
1293 )
1294
1295 @requires_tz_support
1296 def test_split_form(self):
1297 form = EventSplitForm({"dt_0": "2011-09-01", "dt_1": "13:20:30"})
1298 self.assertTrue(form.is_valid())
1299 self.assertEqual(
1300 form.cleaned_data["dt"],
1301 datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC),
1302 )
1303
1304 @requires_tz_support
1305 def test_localized_form(self):
1306 form = EventLocalizedForm(
1307 initial={"dt": datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)}
1308 )
1309 with timezone.override(ICT):
1310 self.assertIn("2011-09-01 17:20:30", str(form))
1311
1312 @requires_tz_support
1313 def test_model_form(self):
1314 EventModelForm({"dt": "2011-09-01 13:20:30"}).save()
1315 e = Event.objects.get()
1316 self.assertEqual(e.dt, datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC))
1317
1318 @requires_tz_support
1319 def test_localized_model_form(self):
1320 form = EventLocalizedModelForm(
1321 instance=Event(dt=datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT))
1322 )
1323 with timezone.override(ICT):
1324 self.assertIn("2011-09-01 17:20:30", str(form))
1325
1326
1327 @translation.override(None)
1328 @override_settings(
1329 DATETIME_FORMAT="c",
1330 TIME_ZONE="Africa/Nairobi",
1331 USE_TZ=True,
1332 ROOT_URLCONF="timezones.urls",
1333 )
1334 class AdminTests(TestCase):
1335 @classmethod
1336 def setUpTestData(cls):
1337 cls.u1 = User.objects.create_user(
1338 password="secret",
1339 last_login=datetime.datetime(2007, 5, 30, 13, 20, 10, tzinfo=UTC),
1340 is_superuser=True,
1341 username="super",
1342 first_name="Super",
1343 last_name="User",
1344 email="[email protected]",
1345 is_staff=True,
1346 is_active=True,
1347 date_joined=datetime.datetime(2007, 5, 30, 13, 20, 10, tzinfo=UTC),
1348 )
1349
1350 def setUp(self):
1351 self.client.force_login(self.u1)
1352
1353 @requires_tz_support
1354 def test_changelist(self):
1355 e = Event.objects.create(
1356 dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
1357 )
1358 response = self.client.get(reverse("admin_tz:timezones_event_changelist"))
1359 self.assertContains(response, e.dt.astimezone(EAT).isoformat())
1360
1361 def test_changelist_in_other_timezone(self):
1362 e = Event.objects.create(
1363 dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
1364 )
1365 with timezone.override(ICT):
1366 response = self.client.get(reverse("admin_tz:timezones_event_changelist"))
1367 self.assertContains(response, e.dt.astimezone(ICT).isoformat())
1368
1369 @requires_tz_support
1370 def test_change_editable(self):
1371 e = Event.objects.create(
1372 dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
1373 )
1374 response = self.client.get(
1375 reverse("admin_tz:timezones_event_change", args=(e.pk,))
1376 )
1377 self.assertContains(response, e.dt.astimezone(EAT).date().isoformat())
1378 self.assertContains(response, e.dt.astimezone(EAT).time().isoformat())
1379
1380 def test_change_editable_in_other_timezone(self):
1381 e = Event.objects.create(
1382 dt=datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC)
1383 )
1384 with timezone.override(ICT):
1385 response = self.client.get(
1386 reverse("admin_tz:timezones_event_change", args=(e.pk,))
1387 )
1388 self.assertContains(response, e.dt.astimezone(ICT).date().isoformat())
1389 self.assertContains(response, e.dt.astimezone(ICT).time().isoformat())
1390
1391 @requires_tz_support
1392 def test_change_readonly(self):
1393 t = Timestamp.objects.create()
1394 response = self.client.get(
1395 reverse("admin_tz:timezones_timestamp_change", args=(t.pk,))
1396 )
1397 self.assertContains(response, t.created.astimezone(EAT).isoformat())
1398
1399 def test_change_readonly_in_other_timezone(self):
1400 t = Timestamp.objects.create()
1401 with timezone.override(ICT):
1402 response = self.client.get(
1403 reverse("admin_tz:timezones_timestamp_change", args=(t.pk,))
1404 )
1405 self.assertContains(response, t.created.astimezone(ICT).isoformat())