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.     def setUp(self):

  13.         self._orig_lang = translation.get_language()

  14.         translation.activate("en-us")

  15. 

  16.     def tearDown(self):

  17.         translation.activate(self._orig_lang)

  18. 

  19.     def test_date(self):

  20.         d = date(2009, 5, 16)

  21.         self.assertEqual(date.fromtimestamp(int(format(d, "U"))), d)

  22. 

  23.     def test_naive_datetime(self):

  24.         dt = datetime(2009, 5, 16, 5, 30, 30)

  25.         self.assertEqual(datetime.fromtimestamp(int(format(dt, "U"))), dt)

  26. 

  27.     def test_naive_ambiguous_datetime(self):

  28.         # dt is ambiguous in Europe/Copenhagen. pytz raises an exception for

  29.         # the ambiguity, which results in an empty string.

  30.         dt = datetime(2015, 10, 25, 2, 30, 0)

  31. 

  32.         # Try all formatters that involve self.timezone.

  33.         self.assertEqual(format(dt, "I"), "")

  34.         self.assertEqual(format(dt, "O"), "")

  35.         self.assertEqual(format(dt, "T"), "")

  36.         self.assertEqual(format(dt, "Z"), "")

  37. 

  38.     @requires_tz_support

  39.     def test_datetime_with_local_tzinfo(self):

  40.         ltz = get_default_timezone()

  41.         dt = make_aware(datetime(2009, 5, 16, 5, 30, 30), ltz)

  42.         self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), ltz), dt)

  43.         self.assertEqual(

  44.             datetime.fromtimestamp(int(format(dt, "U"))), dt.replace(tzinfo=None)

  45.         )

  46. 

  47.     @requires_tz_support

  48.     def test_datetime_with_tzinfo(self):

  49.         tz = get_fixed_timezone(-510)

  50.         ltz = get_default_timezone()

  51.         dt = make_aware(datetime(2009, 5, 16, 5, 30, 30), ltz)

  52.         self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), tz), dt)

  53.         self.assertEqual(datetime.fromtimestamp(int(format(dt, "U")), ltz), dt)

  54.         # astimezone() is safe here because the target timezone doesn't have DST

  55.         self.assertEqual(

  56.             datetime.fromtimestamp(int(format(dt, "U"))),

  57.             dt.astimezone(ltz).replace(tzinfo=None),

  58.         )

  59.         self.assertEqual(

  60.             datetime.fromtimestamp(int(format(dt, "U")), tz).timetuple(),

  61.             dt.astimezone(tz).timetuple(),

  62.         )

  63.         self.assertEqual(

  64.             datetime.fromtimestamp(int(format(dt, "U")), ltz).timetuple(),

  65.             dt.astimezone(ltz).timetuple(),

  66.         )

  67. 

  68.     def test_epoch(self):

  69.         udt = datetime(1970, 1, 1, tzinfo=timezone.utc)

  70.         self.assertEqual(format(udt, "U"), "0")

  71. 

  72.     def test_empty_format(self):

  73.         my_birthday = datetime(1979, 7, 8, 22, 00)

  74. 

  75.         self.assertEqual(dateformat.format(my_birthday, ""), "")

  76. 

  77.     def test_am_pm(self):

  78.         morning = time(7, 00)

  79.         evening = time(19, 00)

  80.         self.assertEqual(dateformat.format(morning, "a"), "a.m.")

  81.         self.assertEqual(dateformat.format(evening, "a"), "p.m.")

  82.         self.assertEqual(dateformat.format(morning, "A"), "AM")

  83.         self.assertEqual(dateformat.format(evening, "A"), "PM")

  84. 

  85.     def test_microsecond(self):

  86.         # Regression test for #18951

  87.         dt = datetime(2009, 5, 16, microsecond=123)

  88.         self.assertEqual(dateformat.format(dt, "u"), "000123")

  89. 

  90.     def test_date_formats(self):

  91.         # Specifiers 'I', 'r', and 'U' are covered in test_timezones().

  92.         my_birthday = datetime(1979, 7, 8, 22, 00)

  93.         for specifier, expected in [

  94.             ("b", "jul"),

  95.             ("d", "08"),

  96.             ("D", "Sun"),

  97.             ("E", "July"),

  98.             ("F", "July"),

  99.             ("j", "8"),

  100.             ("l", "Sunday"),

  101.             ("L", "False"),

  102.             ("m", "07"),

  103.             ("M", "Jul"),

  104.             ("n", "7"),

  105.             ("N", "July"),

  106.             ("o", "1979"),

  107.             ("S", "th"),

  108.             ("t", "31"),

  109.             ("w", "0"),

  110.             ("W", "27"),

  111.             ("y", "79"),

  112.             ("Y", "1979"),

  113.             ("z", "189"),

  114.         ]:

  115.             with self.subTest(specifier=specifier):

  116.                 self.assertEqual(dateformat.format(my_birthday, specifier), expected)

  117. 

  118.     def test_date_formats_c_format(self):

  119.         timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)

  120.         self.assertEqual(

  121.             dateformat.format(timestamp, "c"), "2008-05-19T11:45:23.123456"

  122.         )

  123. 

  124.     def test_time_formats(self):

  125.         # Specifiers 'I', 'r', and 'U' are covered in test_timezones().

  126.         my_birthday = datetime(1979, 7, 8, 22, 00)

  127.         for specifier, expected in [

  128.             ("a", "p.m."),

  129.             ("A", "PM"),

  130.             ("f", "10"),

  131.             ("g", "10"),

  132.             ("G", "22"),

  133.             ("h", "10"),

  134.             ("H", "22"),

  135.             ("i", "00"),

  136.             ("P", "10 p.m."),

  137.             ("s", "00"),

  138.             ("u", "000000"),

  139.         ]:

  140.             with self.subTest(specifier=specifier):

  141.                 self.assertEqual(dateformat.format(my_birthday, specifier), expected)

  142. 

  143.     def test_dateformat(self):

  144.         my_birthday = datetime(1979, 7, 8, 22, 00)

  145. 

  146.         self.assertEqual(dateformat.format(my_birthday, r"Y z \C\E\T"), "1979 189 CET")

  147. 

  148.         self.assertEqual(dateformat.format(my_birthday, r"jS \o\f F"), "8th of July")

  149. 

  150.     def test_futuredates(self):

  151.         the_future = datetime(2100, 10, 25, 0, 00)

  152.         self.assertEqual(dateformat.format(the_future, r"Y"), "2100")

  153. 

  154.     def test_day_of_year_leap(self):

  155.         self.assertEqual(dateformat.format(datetime(2000, 12, 31), "z"), "366")

  156. 

  157.     def test_timezones(self):

  158.         my_birthday = datetime(1979, 7, 8, 22, 00)

  159.         summertime = datetime(2005, 10, 30, 1, 00)

  160.         wintertime = datetime(2005, 10, 30, 4, 00)

  161.         noon = time(12, 0, 0)

  162. 

  163.         # 3h30m to the west of UTC

  164.         tz = get_fixed_timezone(-210)

  165.         aware_dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)

  166. 

  167.         if TZ_SUPPORT:

  168.             for specifier, expected in [

  169.                 ("e", ""),

  170.                 ("O", "+0100"),

  171.                 ("r", "Sun, 08 Jul 1979 22:00:00 +0100"),

  172.                 ("T", "CET"),

  173.                 ("U", "300315600"),

  174.                 ("Z", "3600"),

  175.             ]:

  176.                 with self.subTest(specifier=specifier):

  177.                     self.assertEqual(

  178.                         dateformat.format(my_birthday, specifier), expected

  179.                     )

  180. 

  181.             self.assertEqual(dateformat.format(aware_dt, "e"), "-0330")

  182.             self.assertEqual(

  183.                 dateformat.format(aware_dt, "r"),

  184.                 "Sat, 16 May 2009 05:30:30 -0330",

  185.             )

  186. 

  187.             self.assertEqual(dateformat.format(summertime, "I"), "1")

  188.             self.assertEqual(dateformat.format(summertime, "O"), "+0200")

  189. 

  190.             self.assertEqual(dateformat.format(wintertime, "I"), "0")

  191.             self.assertEqual(dateformat.format(wintertime, "O"), "+0100")

  192. 

  193.             for specifier in ["e", "O", "T", "Z"]:

  194.                 with self.subTest(specifier=specifier):

  195.                     self.assertEqual(dateformat.time_format(noon, specifier), "")

  196. 

  197.         # Ticket #16924 -- We don't need timezone support to test this

  198.         self.assertEqual(dateformat.format(aware_dt, "O"), "-0330")

  199. 

  200.     def test_invalid_time_format_specifiers(self):

  201.         my_birthday = date(1984, 8, 7)

  202. 

  203.         for specifier in ["a", "A", "f", "g", "G", "h", "H", "i", "P", "r", "s", "u"]:

  204.             with self.subTest(specifier=specifier):

  205.                 msg = (

  206.                     "The format for date objects may not contain time-related "

  207.                     f"format specifiers (found {specifier!r})."

  208.                 )

  209.                 with self.assertRaisesMessage(TypeError, msg):

  210.                     dateformat.format(my_birthday, specifier)

  211. 

  212.     @requires_tz_support

  213.     def test_e_format_with_named_time_zone(self):

  214.         dt = datetime(1970, 1, 1, tzinfo=timezone.utc)

  215.         self.assertEqual(dateformat.format(dt, "e"), "UTC")

  216. 

  217.     @requires_tz_support

  218.     def test_e_format_with_time_zone_with_unimplemented_tzname(self):

  219.         class NoNameTZ(tzinfo):

  220.             """Time zone without .tzname() defined."""

  221. 

  222.             def utcoffset(self, dt):

  223.                 return None

  224. 

  225.         dt = datetime(1970, 1, 1, tzinfo=NoNameTZ())

  226.         self.assertEqual(dateformat.format(dt, "e"), "")

  227. 

  228.     def test_P_format(self):

  229.         for expected, t in [

  230.             ("midnight", time(0)),

  231.             ("noon", time(12)),

  232.             ("4 a.m.", time(4)),

  233.             ("8:30 a.m.", time(8, 30)),

  234.             ("4 p.m.", time(16)),

  235.             ("8:30 p.m.", time(20, 30)),

  236.         ]:

  237.             with self.subTest(time=t):

  238.                 self.assertEqual(dateformat.time_format(t, "P"), expected)

  239. 

  240.     def test_r_format_with_non_en_locale(self):

  241.         # Changing the locale doesn't change the "r" format.

  242.         dt = datetime(1979, 7, 8, 22, 00)

  243.         with translation.override("fr"):

  244.             self.assertEqual(

  245.                 dateformat.format(dt, "r"),

  246.                 "Sun, 08 Jul 1979 22:00:00 +0100",

  247.             )

  248. 

  249.     def test_S_format(self):

  250.         for expected, days in [

  251.             ("st", [1, 21, 31]),

  252.             ("nd", [2, 22]),

  253.             ("rd", [3, 23]),

  254.             ("th", (n for n in range(4, 31) if n not in [21, 22, 23])),

  255.         ]:

  256.             for day in days:

  257.                 dt = date(1970, 1, day)

  258.                 with self.subTest(day=day):

  259.                     self.assertEqual(dateformat.format(dt, "S"), expected)

  260. 

  261.     def test_y_format_year_before_1000(self):

  262.         tests = [

  263.             (476, "76"),

  264.             (42, "42"),

  265.             (4, "04"),

  266.         ]

  267.         for year, expected_date in tests:

  268.             with self.subTest(year=year):

  269.                 self.assertEqual(

  270.                     dateformat.format(datetime(year, 9, 8, 5, 0), "y"),

  271.                     expected_date,

  272.                 )

  273. 

  274.     def test_Y_format_year_before_1000(self):

  275.         self.assertEqual(dateformat.format(datetime(1, 1, 1), "Y"), "0001")

  276.         self.assertEqual(dateformat.format(datetime(999, 1, 1), "Y"), "0999")

  277. 

  278.     def test_twelve_hour_format(self):

  279.         tests = [

  280.             (0, "12", "12"),

  281.             (1, "1", "01"),

  282.             (11, "11", "11"),

  283.             (12, "12", "12"),

  284.             (13, "1", "01"),

  285.             (23, "11", "11"),

  286.         ]

  287.         for hour, g_expected, h_expected in tests:

  288.             dt = datetime(2000, 1, 1, hour)

  289.             with self.subTest(hour=hour):

  290.                 self.assertEqual(dateformat.format(dt, "g"), g_expected)

  291.                 self.assertEqual(dateformat.format(dt, "h"), h_expected)
About Sign Up Leave Feedback Contact