Debian Codegraph @

tests/utils_tests/test_dateformat.py

raw
1 from datetime import date, datetime, time, timezone, tzinfo
2
3 from django.test import SimpleTestCase, override_settings
4 from django.test.utils import TZ_SUPPORT, requires_tz_support
5 from django.utils import dateformat, translation
6 from django.utils.dateformat import format
7 from django.utils.timezone import get_default_timezone, get_fixed_timezone, make_aware
8
9
10 @override_settings(TIME_ZONE="Europe/Copenhagen")
11 class DateFormatTests(SimpleTestCase):
12 @classmethod
13 def setUpClass(cls):
14 cls.enterClassContext(translation.override("en-us"))
15 super().setUpClass()
16
17 def test_date(self):
18 d = date(2009, 5, 16)
19 self.assertEqual(date.fromtimestamp(int(format(d, "U"))), d)
20
21 def test_naive_datetime(self):
22 dt = datetime(2009, 5, 16, 5, 30, 30)
23 self.assertEqual(datetime.fromtimestamp(int(format(dt, "U"))), dt)
24
25 def test_naive_ambiguous_datetime(self):
26 # dt is ambiguous in Europe/Copenhagen.
27 dt = datetime(2015, 10, 25, 2, 30, 0)
28
29 # Try all formatters that involve self.timezone.
30 self.assertEqual(format(dt, "I"), "")
31 self.assertEqual(format(dt, "O"), "")
32 self.assertEqual(format(dt, "T"), "")
33 self.assertEqual(format(dt, "Z"), "")
34
35 @requires_tz_support
36 def test_datetime_with_local_tzinfo(self):
37 ltz = get_default_timezone()
38 dt = make_aware(datetime(2009, 5, 16, 5, 30, 30), ltz)
39 self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), ltz), dt)
40 self.assertEqual(
41 datetime.fromtimestamp(int(format(dt, "U"))), dt.replace(tzinfo=None)
42 )
43
44 @requires_tz_support
45 def test_datetime_with_tzinfo(self):
46 tz = get_fixed_timezone(-510)
47 ltz = get_default_timezone()
48 dt = make_aware(datetime(2009, 5, 16, 5, 30, 30), ltz)
49 self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), tz), dt)
50 self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), ltz), dt)
51 # astimezone() is safe here because the target timezone doesn't have DST
52 self.assertEqual(
53 datetime.fromtimestamp(int(format(dt, "U"))),
54 dt.astimezone(ltz).replace(tzinfo=None),
55 )
56 self.assertEqual(
57 datetime.fromtimestamp(int(format(dt, "U")), tz).timetuple(),
58 dt.astimezone(tz).timetuple(),
59 )
60 self.assertEqual(
61 datetime.fromtimestamp(int(format(dt, "U")), ltz).timetuple(),
62 dt.astimezone(ltz).timetuple(),
63 )
64
65 def test_epoch(self):
66 udt = datetime(1970, 1, 1, tzinfo=timezone.utc)
67 self.assertEqual(format(udt, "U"), "0")
68
69 def test_empty_format(self):
70 my_birthday = datetime(1979, 7, 8, 22, 00)
71
72 self.assertEqual(dateformat.format(my_birthday, ""), "")
73
74 def test_am_pm(self):
75 morning = time(7, 00)
76 evening = time(19, 00)
77 self.assertEqual(dateformat.format(morning, "a"), "a.m.")
78 self.assertEqual(dateformat.format(evening, "a"), "p.m.")
79 self.assertEqual(dateformat.format(morning, "A"), "AM")
80 self.assertEqual(dateformat.format(evening, "A"), "PM")
81
82 def test_microsecond(self):
83 # Regression test for #18951
84 dt = datetime(2009, 5, 16, microsecond=123)
85 self.assertEqual(dateformat.format(dt, "u"), "000123")
86
87 def test_date_formats(self):
88 # Specifiers 'I', 'r', and 'U' are covered in test_timezones().
89 my_birthday = datetime(1979, 7, 8, 22, 00)
90 for specifier, expected in [
91 ("b", "jul"),
92 ("d", "08"),
93 ("D", "Sun"),
94 ("E", "July"),
95 ("F", "July"),
96 ("j", "8"),
97 ("l", "Sunday"),
98 ("L", "False"),
99 ("m", "07"),
100 ("M", "Jul"),
101 ("n", "7"),
102 ("N", "July"),
103 ("o", "1979"),
104 ("S", "th"),
105 ("t", "31"),
106 ("w", "0"),
107 ("W", "27"),
108 ("y", "79"),
109 ("Y", "1979"),
110 ("z", "189"),
111 ]:
112 with self.subTest(specifier=specifier):
113 self.assertEqual(dateformat.format(my_birthday, specifier), expected)
114
115 def test_date_formats_c_format(self):
116 timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)
117 self.assertEqual(
118 dateformat.format(timestamp, "c"), "2008-05-19T11:45:23.123456"
119 )
120
121 def test_time_formats(self):
122 # Specifiers 'I', 'r', and 'U' are covered in test_timezones().
123 my_birthday = datetime(1979, 7, 8, 22, 00)
124 for specifier, expected in [
125 ("a", "p.m."),
126 ("A", "PM"),
127 ("f", "10"),
128 ("g", "10"),
129 ("G", "22"),
130 ("h", "10"),
131 ("H", "22"),
132 ("i", "00"),
133 ("P", "10 p.m."),
134 ("s", "00"),
135 ("u", "000000"),
136 ]:
137 with self.subTest(specifier=specifier):
138 self.assertEqual(dateformat.format(my_birthday, specifier), expected)
139
140 def test_dateformat(self):
141 my_birthday = datetime(1979, 7, 8, 22, 00)
142
143 self.assertEqual(dateformat.format(my_birthday, r"Y z \C\E\T"), "1979 189 CET")
144
145 self.assertEqual(dateformat.format(my_birthday, r"jS \o\f F"), "8th of July")
146
147 def test_futuredates(self):
148 the_future = datetime(2100, 10, 25, 0, 00)
149 self.assertEqual(dateformat.format(the_future, r"Y"), "2100")
150
151 def test_day_of_year_leap(self):
152 self.assertEqual(dateformat.format(datetime(2000, 12, 31), "z"), "366")
153
154 def test_timezones(self):
155 my_birthday = datetime(1979, 7, 8, 22, 00)
156 summertime = datetime(2005, 10, 30, 1, 00)
157 wintertime = datetime(2005, 10, 30, 4, 00)
158 noon = time(12, 0, 0)
159
160 # 3h30m to the west of UTC
161 tz = get_fixed_timezone(-210)
162 aware_dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)
163
164 if TZ_SUPPORT:
165 for specifier, expected in [
166 ("e", ""),
167 ("O", "+0100"),
168 ("r", "Sun, 08 Jul 1979 22:00:00 +0100"),
169 ("T", "CET"),
170 ("U", "300315600"),
171 ("Z", "3600"),
172 ]:
173 with self.subTest(specifier=specifier):
174 self.assertEqual(
175 dateformat.format(my_birthday, specifier), expected
176 )
177
178 self.assertEqual(dateformat.format(aware_dt, "e"), "-0330")
179 self.assertEqual(
180 dateformat.format(aware_dt, "r"),
181 "Sat, 16 May 2009 05:30:30 -0330",
182 )
183
184 self.assertEqual(dateformat.format(summertime, "I"), "1")
185 self.assertEqual(dateformat.format(summertime, "O"), "+0200")
186
187 self.assertEqual(dateformat.format(wintertime, "I"), "0")
188 self.assertEqual(dateformat.format(wintertime, "O"), "+0100")
189
190 for specifier in ["e", "O", "T", "Z"]:
191 with self.subTest(specifier=specifier):
192 self.assertEqual(dateformat.time_format(noon, specifier), "")
193
194 # Ticket #16924 -- We don't need timezone support to test this
195 self.assertEqual(dateformat.format(aware_dt, "O"), "-0330")
196
197 def test_invalid_time_format_specifiers(self):
198 my_birthday = date(1984, 8, 7)
199
200 for specifier in ["a", "A", "f", "g", "G", "h", "H", "i", "P", "s", "u"]:
201 with self.subTest(specifier=specifier):
202 msg = (
203 "The format for date objects may not contain time-related "
204 f"format specifiers (found {specifier!r})."
205 )
206 with self.assertRaisesMessage(TypeError, msg):
207 dateformat.format(my_birthday, specifier)
208
209 @requires_tz_support
210 def test_e_format_with_named_time_zone(self):
211 dt = datetime(1970, 1, 1, tzinfo=timezone.utc)
212 self.assertEqual(dateformat.format(dt, "e"), "UTC")
213
214 @requires_tz_support
215 def test_e_format_with_time_zone_with_unimplemented_tzname(self):
216 class NoNameTZ(tzinfo):
217 """Time zone without .tzname() defined."""
218
219 def utcoffset(self, dt):
220 return None
221
222 dt = datetime(1970, 1, 1, tzinfo=NoNameTZ())
223 self.assertEqual(dateformat.format(dt, "e"), "")
224
225 def test_P_format(self):
226 for expected, t in [
227 ("midnight", time(0)),
228 ("noon", time(12)),
229 ("4 a.m.", time(4)),
230 ("8:30 a.m.", time(8, 30)),
231 ("4 p.m.", time(16)),
232 ("8:30 p.m.", time(20, 30)),
233 ]:
234 with self.subTest(time=t):
235 self.assertEqual(dateformat.time_format(t, "P"), expected)
236
237 def test_r_format_with_date(self):
238 # Assume midnight in default timezone if datetime.date provided.
239 dt = date(2022, 7, 1)
240 self.assertEqual(
241 dateformat.format(dt, "r"),
242 "Fri, 01 Jul 2022 00:00:00 +0200",
243 )
244
245 def test_r_format_with_non_en_locale(self):
246 # Changing the locale doesn't change the "r" format.
247 dt = datetime(1979, 7, 8, 22, 00)
248 with translation.override("fr"):
249 self.assertEqual(
250 dateformat.format(dt, "r"),
251 "Sun, 08 Jul 1979 22:00:00 +0100",
252 )
253
254 def test_S_format(self):
255 for expected, days in [
256 ("st", [1, 21, 31]),
257 ("nd", [2, 22]),
258 ("rd", [3, 23]),
259 ("th", (n for n in range(4, 31) if n not in [21, 22, 23])),
260 ]:
261 for day in days:
262 dt = date(1970, 1, day)
263 with self.subTest(day=day):
264 self.assertEqual(dateformat.format(dt, "S"), expected)
265
266 def test_y_format_year_before_1000(self):
267 tests = [
268 (476, "76"),
269 (42, "42"),
270 (4, "04"),
271 ]
272 for year, expected_date in tests:
273 with self.subTest(year=year):
274 self.assertEqual(
275 dateformat.format(datetime(year, 9, 8, 5, 0), "y"),
276 expected_date,
277 )
278
279 def test_Y_format_year_before_1000(self):
280 self.assertEqual(dateformat.format(datetime(1, 1, 1), "Y"), "0001")
281 self.assertEqual(dateformat.format(datetime(999, 1, 1), "Y"), "0999")
282
283 def test_twelve_hour_format(self):
284 tests = [
285 (0, "12", "12"),
286 (1, "1", "01"),
287 (11, "11", "11"),
288 (12, "12", "12"),
289 (13, "1", "01"),
290 (23, "11", "11"),
291 ]
292 for hour, g_expected, h_expected in tests:
293 dt = datetime(2000, 1, 1, hour)
294 with self.subTest(hour=hour):
295 self.assertEqual(dateformat.format(dt, "g"), g_expected)
296 self.assertEqual(dateformat.format(dt, "h"), h_expected)