| 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) |