| 1 |
import datetime |
| 2 |
import zoneinfo |
| 3 |
|
| 4 |
from django.test import TestCase |
| 5 |
from django.test.utils import override_settings, requires_tz_support |
| 6 |
from django.utils import timezone, translation |
| 7 |
from django.utils.timesince import timesince, timeuntil |
| 8 |
from django.utils.translation import npgettext_lazy |
| 9 |
|
| 10 |
|
| 11 |
class TimesinceTests(TestCase): |
| 12 |
def setUp(self): |
| 13 |
self.t = datetime.datetime(2007, 8, 14, 13, 46, 0) |
| 14 |
self.onemicrosecond = datetime.timedelta(microseconds=1) |
| 15 |
self.onesecond = datetime.timedelta(seconds=1) |
| 16 |
self.oneminute = datetime.timedelta(minutes=1) |
| 17 |
self.onehour = datetime.timedelta(hours=1) |
| 18 |
self.oneday = datetime.timedelta(days=1) |
| 19 |
self.oneweek = datetime.timedelta(days=7) |
| 20 |
self.onemonth = datetime.timedelta(days=31) |
| 21 |
self.oneyear = datetime.timedelta(days=366) |
| 22 |
|
| 23 |
def test_equal_datetimes(self): |
| 24 |
"""equal datetimes.""" |
| 25 |
# NOTE: \xa0 avoids wrapping between value and unit |
| 26 |
self.assertEqual(timesince(self.t, self.t), "0\xa0minutes") |
| 27 |
|
| 28 |
def test_ignore_microseconds_and_seconds(self): |
| 29 |
"""Microseconds and seconds are ignored.""" |
| 30 |
self.assertEqual( |
| 31 |
timesince(self.t, self.t + self.onemicrosecond), "0\xa0minutes" |
| 32 |
) |
| 33 |
self.assertEqual(timesince(self.t, self.t + self.onesecond), "0\xa0minutes") |
| 34 |
|
| 35 |
def test_other_units(self): |
| 36 |
"""Test other units.""" |
| 37 |
self.assertEqual(timesince(self.t, self.t + self.oneminute), "1\xa0minute") |
| 38 |
self.assertEqual(timesince(self.t, self.t + self.onehour), "1\xa0hour") |
| 39 |
self.assertEqual(timesince(self.t, self.t + self.oneday), "1\xa0day") |
| 40 |
self.assertEqual(timesince(self.t, self.t + self.oneweek), "1\xa0week") |
| 41 |
self.assertEqual(timesince(self.t, self.t + self.onemonth), "1\xa0month") |
| 42 |
self.assertEqual(timesince(self.t, self.t + self.oneyear), "1\xa0year") |
| 43 |
|
| 44 |
def test_multiple_units(self): |
| 45 |
"""Test multiple units.""" |
| 46 |
self.assertEqual( |
| 47 |
timesince(self.t, self.t + 2 * self.oneday + 6 * self.onehour), |
| 48 |
"2\xa0days, 6\xa0hours", |
| 49 |
) |
| 50 |
self.assertEqual( |
| 51 |
timesince(self.t, self.t + 2 * self.oneweek + 2 * self.oneday), |
| 52 |
"2\xa0weeks, 2\xa0days", |
| 53 |
) |
| 54 |
|
| 55 |
def test_display_first_unit(self): |
| 56 |
""" |
| 57 |
If the two differing units aren't adjacent, only the first unit is |
| 58 |
displayed. |
| 59 |
""" |
| 60 |
self.assertEqual( |
| 61 |
timesince( |
| 62 |
self.t, |
| 63 |
self.t + 2 * self.oneweek + 3 * self.onehour + 4 * self.oneminute, |
| 64 |
), |
| 65 |
"2\xa0weeks", |
| 66 |
) |
| 67 |
self.assertEqual( |
| 68 |
timesince(self.t, self.t + 4 * self.oneday + 5 * self.oneminute), |
| 69 |
"4\xa0days", |
| 70 |
) |
| 71 |
|
| 72 |
def test_display_second_before_first(self): |
| 73 |
""" |
| 74 |
When the second date occurs before the first, we should always |
| 75 |
get 0 minutes. |
| 76 |
""" |
| 77 |
self.assertEqual( |
| 78 |
timesince(self.t, self.t - self.onemicrosecond), "0\xa0minutes" |
| 79 |
) |
| 80 |
self.assertEqual(timesince(self.t, self.t - self.onesecond), "0\xa0minutes") |
| 81 |
self.assertEqual(timesince(self.t, self.t - self.oneminute), "0\xa0minutes") |
| 82 |
self.assertEqual(timesince(self.t, self.t - self.onehour), "0\xa0minutes") |
| 83 |
self.assertEqual(timesince(self.t, self.t - self.oneday), "0\xa0minutes") |
| 84 |
self.assertEqual(timesince(self.t, self.t - self.oneweek), "0\xa0minutes") |
| 85 |
self.assertEqual(timesince(self.t, self.t - self.onemonth), "0\xa0minutes") |
| 86 |
self.assertEqual(timesince(self.t, self.t - self.oneyear), "0\xa0minutes") |
| 87 |
self.assertEqual( |
| 88 |
timesince(self.t, self.t - 2 * self.oneday - 6 * self.onehour), |
| 89 |
"0\xa0minutes", |
| 90 |
) |
| 91 |
self.assertEqual( |
| 92 |
timesince(self.t, self.t - 2 * self.oneweek - 2 * self.oneday), |
| 93 |
"0\xa0minutes", |
| 94 |
) |
| 95 |
self.assertEqual( |
| 96 |
timesince( |
| 97 |
self.t, |
| 98 |
self.t - 2 * self.oneweek - 3 * self.onehour - 4 * self.oneminute, |
| 99 |
), |
| 100 |
"0\xa0minutes", |
| 101 |
) |
| 102 |
self.assertEqual( |
| 103 |
timesince(self.t, self.t - 4 * self.oneday - 5 * self.oneminute), |
| 104 |
"0\xa0minutes", |
| 105 |
) |
| 106 |
|
| 107 |
def test_second_before_equal_first_humanize_time_strings(self): |
| 108 |
time_strings = { |
| 109 |
"minute": npgettext_lazy( |
| 110 |
"naturaltime-future", |
| 111 |
"%(num)d minute", |
| 112 |
"%(num)d minutes", |
| 113 |
"num", |
| 114 |
), |
| 115 |
} |
| 116 |
with translation.override("cs"): |
| 117 |
for now in [self.t, self.t - self.onemicrosecond, self.t - self.oneday]: |
| 118 |
with self.subTest(now): |
| 119 |
self.assertEqual( |
| 120 |
timesince(self.t, now, time_strings=time_strings), |
| 121 |
"0\xa0minut", |
| 122 |
) |
| 123 |
|
| 124 |
@requires_tz_support |
| 125 |
def test_different_timezones(self): |
| 126 |
"""When using two different timezones.""" |
| 127 |
now = datetime.datetime.now() |
| 128 |
now_tz = timezone.make_aware(now, timezone.get_default_timezone()) |
| 129 |
now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195)) |
| 130 |
|
| 131 |
self.assertEqual(timesince(now), "0\xa0minutes") |
| 132 |
self.assertEqual(timesince(now_tz), "0\xa0minutes") |
| 133 |
self.assertEqual(timesince(now_tz_i), "0\xa0minutes") |
| 134 |
self.assertEqual(timesince(now_tz, now_tz_i), "0\xa0minutes") |
| 135 |
self.assertEqual(timeuntil(now), "0\xa0minutes") |
| 136 |
self.assertEqual(timeuntil(now_tz), "0\xa0minutes") |
| 137 |
self.assertEqual(timeuntil(now_tz_i), "0\xa0minutes") |
| 138 |
self.assertEqual(timeuntil(now_tz, now_tz_i), "0\xa0minutes") |
| 139 |
|
| 140 |
def test_date_objects(self): |
| 141 |
"""Both timesince and timeuntil should work on date objects (#17937).""" |
| 142 |
today = datetime.date.today() |
| 143 |
self.assertEqual(timesince(today + self.oneday), "0\xa0minutes") |
| 144 |
self.assertEqual(timeuntil(today - self.oneday), "0\xa0minutes") |
| 145 |
|
| 146 |
def test_both_date_objects(self): |
| 147 |
"""Timesince should work with both date objects (#9672)""" |
| 148 |
today = datetime.date.today() |
| 149 |
self.assertEqual(timeuntil(today + self.oneday, today), "1\xa0day") |
| 150 |
self.assertEqual(timeuntil(today - self.oneday, today), "0\xa0minutes") |
| 151 |
self.assertEqual(timeuntil(today + self.oneweek, today), "1\xa0week") |
| 152 |
|
| 153 |
def test_leap_year(self): |
| 154 |
start_date = datetime.date(2016, 12, 25) |
| 155 |
self.assertEqual(timeuntil(start_date + self.oneweek, start_date), "1\xa0week") |
| 156 |
self.assertEqual(timesince(start_date, start_date + self.oneweek), "1\xa0week") |
| 157 |
|
| 158 |
def test_leap_year_new_years_eve(self): |
| 159 |
t = datetime.date(2016, 12, 31) |
| 160 |
now = datetime.datetime(2016, 12, 31, 18, 0, 0) |
| 161 |
self.assertEqual(timesince(t + self.oneday, now), "0\xa0minutes") |
| 162 |
self.assertEqual(timeuntil(t - self.oneday, now), "0\xa0minutes") |
| 163 |
|
| 164 |
def test_naive_datetime_with_tzinfo_attribute(self): |
| 165 |
class naive(datetime.tzinfo): |
| 166 |
def utcoffset(self, dt): |
| 167 |
return None |
| 168 |
|
| 169 |
future = datetime.datetime(2080, 1, 1, tzinfo=naive()) |
| 170 |
self.assertEqual(timesince(future), "0\xa0minutes") |
| 171 |
past = datetime.datetime(1980, 1, 1, tzinfo=naive()) |
| 172 |
self.assertEqual(timeuntil(past), "0\xa0minutes") |
| 173 |
|
| 174 |
def test_thousand_years_ago(self): |
| 175 |
t = self.t.replace(year=self.t.year - 1000) |
| 176 |
self.assertEqual(timesince(t, self.t), "1000\xa0years") |
| 177 |
self.assertEqual(timeuntil(self.t, t), "1000\xa0years") |
| 178 |
|
| 179 |
def test_depth(self): |
| 180 |
t = ( |
| 181 |
self.t |
| 182 |
+ self.oneyear |
| 183 |
+ self.onemonth |
| 184 |
+ self.oneweek |
| 185 |
+ self.oneday |
| 186 |
+ self.onehour |
| 187 |
) |
| 188 |
tests = [ |
| 189 |
(t, 1, "1\xa0year"), |
| 190 |
(t, 2, "1\xa0year, 1\xa0month"), |
| 191 |
(t, 3, "1\xa0year, 1\xa0month, 1\xa0week"), |
| 192 |
(t, 4, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day"), |
| 193 |
(t, 5, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour"), |
| 194 |
(t, 6, "1\xa0year, 1\xa0month, 1\xa0week, 1\xa0day, 1\xa0hour"), |
| 195 |
(self.t + self.onehour, 5, "1\xa0hour"), |
| 196 |
(self.t + (4 * self.oneminute), 3, "4\xa0minutes"), |
| 197 |
(self.t + self.onehour + self.oneminute, 1, "1\xa0hour"), |
| 198 |
(self.t + self.oneday + self.onehour, 1, "1\xa0day"), |
| 199 |
(self.t + self.oneweek + self.oneday, 1, "1\xa0week"), |
| 200 |
(self.t + self.onemonth + self.oneweek, 1, "1\xa0month"), |
| 201 |
(self.t + self.oneyear + self.onemonth, 1, "1\xa0year"), |
| 202 |
(self.t + self.oneyear + self.oneweek + self.oneday, 3, "1\xa0year"), |
| 203 |
] |
| 204 |
for value, depth, expected in tests: |
| 205 |
with self.subTest(): |
| 206 |
self.assertEqual(timesince(self.t, value, depth=depth), expected) |
| 207 |
self.assertEqual(timeuntil(value, self.t, depth=depth), expected) |
| 208 |
|
| 209 |
def test_months_edge(self): |
| 210 |
t = datetime.datetime(2022, 1, 1) |
| 211 |
tests = [ |
| 212 |
(datetime.datetime(2022, 1, 31), "4\xa0weeks, 2\xa0days"), |
| 213 |
(datetime.datetime(2022, 2, 1), "1\xa0month"), |
| 214 |
(datetime.datetime(2022, 2, 28), "1\xa0month, 3\xa0weeks"), |
| 215 |
(datetime.datetime(2022, 3, 1), "2\xa0months"), |
| 216 |
(datetime.datetime(2022, 3, 31), "2\xa0months, 4\xa0weeks"), |
| 217 |
(datetime.datetime(2022, 4, 1), "3\xa0months"), |
| 218 |
(datetime.datetime(2022, 4, 30), "3\xa0months, 4\xa0weeks"), |
| 219 |
(datetime.datetime(2022, 5, 1), "4\xa0months"), |
| 220 |
(datetime.datetime(2022, 5, 31), "4\xa0months, 4\xa0weeks"), |
| 221 |
(datetime.datetime(2022, 6, 1), "5\xa0months"), |
| 222 |
(datetime.datetime(2022, 6, 30), "5\xa0months, 4\xa0weeks"), |
| 223 |
(datetime.datetime(2022, 7, 1), "6\xa0months"), |
| 224 |
(datetime.datetime(2022, 7, 31), "6\xa0months, 4\xa0weeks"), |
| 225 |
(datetime.datetime(2022, 8, 1), "7\xa0months"), |
| 226 |
(datetime.datetime(2022, 8, 31), "7\xa0months, 4\xa0weeks"), |
| 227 |
(datetime.datetime(2022, 9, 1), "8\xa0months"), |
| 228 |
(datetime.datetime(2022, 9, 30), "8\xa0months, 4\xa0weeks"), |
| 229 |
(datetime.datetime(2022, 10, 1), "9\xa0months"), |
| 230 |
(datetime.datetime(2022, 10, 31), "9\xa0months, 4\xa0weeks"), |
| 231 |
(datetime.datetime(2022, 11, 1), "10\xa0months"), |
| 232 |
(datetime.datetime(2022, 11, 30), "10\xa0months, 4\xa0weeks"), |
| 233 |
(datetime.datetime(2022, 12, 1), "11\xa0months"), |
| 234 |
(datetime.datetime(2022, 12, 31), "11\xa0months, 4\xa0weeks"), |
| 235 |
] |
| 236 |
for value, expected in tests: |
| 237 |
with self.subTest(): |
| 238 |
self.assertEqual(timesince(t, value), expected) |
| 239 |
|
| 240 |
def test_depth_invalid(self): |
| 241 |
msg = "depth must be greater than 0." |
| 242 |
with self.assertRaisesMessage(ValueError, msg): |
| 243 |
timesince(self.t, self.t, depth=0) |
| 244 |
|
| 245 |
@requires_tz_support |
| 246 |
def test_less_than_a_day_with_zoneinfo(self): |
| 247 |
now_with_zoneinfo = timezone.now().astimezone( |
| 248 |
zoneinfo.ZoneInfo(key="Asia/Kathmandu") # UTC+05:45 |
| 249 |
) |
| 250 |
tests = [ |
| 251 |
(now_with_zoneinfo, "0\xa0minutes"), |
| 252 |
(now_with_zoneinfo - self.onemicrosecond, "0\xa0minutes"), |
| 253 |
(now_with_zoneinfo - self.onesecond, "0\xa0minutes"), |
| 254 |
(now_with_zoneinfo - self.oneminute, "1\xa0minute"), |
| 255 |
(now_with_zoneinfo - self.onehour, "1\xa0hour"), |
| 256 |
] |
| 257 |
for value, expected in tests: |
| 258 |
with self.subTest(value): |
| 259 |
self.assertEqual(timesince(value), expected) |
| 260 |
|
| 261 |
@requires_tz_support |
| 262 |
def test_less_than_a_day_cross_day_with_zoneinfo(self): |
| 263 |
now_with_zoneinfo = timezone.make_aware( |
| 264 |
datetime.datetime(2023, 4, 14, 1, 30, 30), |
| 265 |
zoneinfo.ZoneInfo(key="Asia/Kathmandu"), # UTC+05:45 |
| 266 |
) |
| 267 |
now_utc = now_with_zoneinfo.astimezone(datetime.timezone.utc) |
| 268 |
tests = [ |
| 269 |
(now_with_zoneinfo, "0\xa0minutes"), |
| 270 |
(now_with_zoneinfo - self.onemicrosecond, "0\xa0minutes"), |
| 271 |
(now_with_zoneinfo - self.onesecond, "0\xa0minutes"), |
| 272 |
(now_with_zoneinfo - self.oneminute, "1\xa0minute"), |
| 273 |
(now_with_zoneinfo - self.onehour, "1\xa0hour"), |
| 274 |
] |
| 275 |
for value, expected in tests: |
| 276 |
with self.subTest(value): |
| 277 |
self.assertEqual(timesince(value, now_utc), expected) |
| 278 |
|
| 279 |
|
| 280 |
@requires_tz_support |
| 281 |
@override_settings(USE_TZ=True) |
| 282 |
class TZAwareTimesinceTests(TimesinceTests): |
| 283 |
def setUp(self): |
| 284 |
super().setUp() |
| 285 |
self.t = timezone.make_aware(self.t, timezone.get_default_timezone()) |