fix(circulation): prevent test failures after 23:00 UTC

Tests comparing loan due-dates against datetime.now() would fail when
run after 23:00 UTC because the loan creation and the assertion could
straddle midnight CET (UTC+1/+2) and land on different calendar days.

- libraries/api.py: always convert input to library local timezone
  before checking day name and opening times in is_open()
- test_loans_rest.py: freeze time around checkout + assertion so both
  calls see the same instant
- test_actions_extend.py: freeze time around extend_loan() + assertion
  for the same reason; use timezone-aware datetime.now(timezone.utc)
- test_extend_external.py: mirror the next_open() logic used by
  get_extension_params() so the expected date is computed the same way

Co-Authored-by: Peter Weber <peter.weber@rero.ch>
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: rerowep

rero_ils/modules/libraries/api.py

@@ -223,9 +223,14 @@ def _get_exceptions_matching_date(self, date_to_check, day_only=False):
             # date_to_check) and get only the last one.
             if exception.get("repeat"):
                 period = exception["repeat"]["period"].upper()
+                # Use end-of-day as the rrule upper bound. date_to_check may
+                # be in a local timezone (e.g. CEST) whose midnight is earlier
+                # than midnight UTC, which would cause the rrule to miss a
+                # recurrence that falls on the same calendar day in UTC.
+                until = date_to_check.replace(hour=23, minute=59, second=59, microsecond=999999)
                 exception_dates = rrule(
                     freq=FREQNAMES.index(period),
-                    until=date_to_check,
+                    until=until,
                     interval=exception["repeat"]["interval"],
                     dtstart=start_date,
                 )
@@ -256,6 +261,18 @@ def is_open(self, date=None, day_only=False):
             date = date_string_to_utc(date)
         if isinstance(date, datetime) and date.tzinfo is None:
             date = date.replace(tzinfo=pytz.utc)
+        # When the caller passes midnight (00:00:00), it signals a "date-only"
+        # query — they want to know whether the library is open at all that day,
+        # not at a specific time. _is_betweentimes() relies on midnight to
+        # trigger exactly this logic, so we must preserve the sentinel after the
+        # timezone conversion below.
+        date_only_query = date.hour == date.minute == date.second == 0
+        # Always evaluate in library local time so day names and opening hours
+        # are compared in the correct timezone regardless of what tz the caller
+        # passed in (UTC, local, etc.).
+        date = date.astimezone(self.get_timezone())
+        if date_only_query:
+            date = date.replace(hour=0, minute=0, second=0, microsecond=0)
 
         # STEP 1 :: check about regular rules
         #   Each library could define if a specific weekday is open or closed.

tests/api/loans/test_loans_rest.py

@@ -23,6 +23,7 @@
 import ciso8601
 import pytz
 from flask import url_for
+from freezegun import freeze_time
 from invenio_accounts.testutils import login_user_via_session
 from invenio_circulation.api import get_loan_for_item
 
@@ -583,41 +584,50 @@ def test_timezone_due_date(
     # Login to perform action
     login_user_via_session(client, librarian_martigny.user)
 
-    # Checkout the item
-    res, data = postdata(
-        client,
-        "api_item.checkout",
-        {
-            "item_pid": item_pid,
-            "patron_pid": patron_pid,
-            "transaction_location_pid": loc_public_martigny.pid,
-            "transaction_user_pid": librarian_martigny.pid,
-        },
-    )
-    assert res.status_code == 200
-
-    # Get Loan date (should be in UTC)
-    loan_pid = data.get("action_applied")[LoanAction.CHECKOUT].get("pid")
-    loan = Loan.get_record_by_pid(loan_pid)
-    loan_end_date = loan.get("end_date")
-
-    # Get next library open date (should be next monday after X-1 days) where
-    # X is checkout_duration
-    soon = datetime.now(pytz.utc) + timedelta(days=(checkout_duration - 1))
-    lib = Library.get_record_by_pid(item.library_pid)
-    lib_datetime = lib.next_open(soon)
-
-    # Loan date should be in UTC (as lib_datetime).
-    loan_datetime = ciso8601.parse_datetime(loan_end_date)
-
-    # Compare year, month and date for Loan due date: should be the same!
-    fail_msg = "Check timezone for Loan and Library. \
+    # Freeze time around the checkout and the subsequent assertion so both see
+    # the same instant. Without this, datetime.now() inside the loan creation
+    # and datetime.now() in the assertion could straddle midnight (CET = UTC+1)
+    # and produce different library-local calendar days, causing a spurious
+    # failure when tests run after 23:00 UTC.
+    frozen_now = datetime.now(timezone.utc)
+    with freeze_time(frozen_now):
+        # Checkout the item
+        res, data = postdata(
+            client,
+            "api_item.checkout",
+            {
+                "item_pid": item_pid,
+                "patron_pid": patron_pid,
+                "transaction_location_pid": loc_public_martigny.pid,
+                "transaction_user_pid": librarian_martigny.pid,
+            },
+        )
+        assert res.status_code == 200
+
+        # Get Loan date (should be in UTC)
+        loan_pid = data.get("action_applied")[LoanAction.CHECKOUT].get("pid")
+        loan = Loan.get_record_by_pid(loan_pid)
+        loan_end_date = loan.get("end_date")
+
+        # Get next library open date (should be next monday after X-1 days) where
+        # X is checkout_duration. Use library local time, same as the loan
+        # computation, so results match across UTC/local day boundaries.
+        lib = Library.get_record_by_pid(item.library_pid)
+        lib_tz = lib.get_timezone()
+        soon = datetime.now(pytz.utc).astimezone(lib_tz) + timedelta(days=checkout_duration - 1)
+        lib_datetime = lib.next_open(soon)
+
+        # Loan date should be in UTC (as lib_datetime).
+        loan_datetime = ciso8601.parse_datetime(loan_end_date)
+
+        # Compare year, month and date for Loan due date: should be the same!
+        fail_msg = "Check timezone for Loan and Library. \
 It should be the same date, even if timezone changed."
-    assert loan_datetime.year == lib_datetime.year, fail_msg
-    assert loan_datetime.month == lib_datetime.month, fail_msg
-    assert loan_datetime.day == lib_datetime.day, fail_msg
-    # Loan date differs regarding timezone, and day of the year (GMT+1/2).
-    check_timezone_date(pytz.utc, loan_datetime, [21, 22])
+        assert loan_datetime.year == lib_datetime.year, fail_msg
+        assert loan_datetime.month == lib_datetime.month, fail_msg
+        assert loan_datetime.day == lib_datetime.day, fail_msg
+        # Loan date differs regarding timezone, and day of the year (GMT+1/2).
+        check_timezone_date(pytz.utc, loan_datetime, [21, 22])
 
 
 def test_librarian_request_on_blocked_user(

tests/ui/circulation/test_actions_extend.py

@@ -22,6 +22,7 @@
 
 import ciso8601
 import pytest
+from freezegun import freeze_time
 from invenio_circulation.errors import CirculationException
 
 from rero_ils.modules.circ_policies.api import CircPolicy
@@ -231,21 +232,27 @@ def test_extend_on_item_on_loan_with_no_requests(
 
     app.config["CIRCULATION_POLICIES"]["extension"]["from_end_date"] = False
     initial_loan = loan.update(initial_loan_data, dbcommit=True, reindex=True)
-    # Extend the loan
+    # Freeze time so extend_loan() and the assertion both observe the same
+    # instant. Without this, the two datetime.now() calls could straddle
+    # midnight CET (UTC+1) when tests run after 23:00 UTC and produce
+    # different library-local calendar days.
     params = {
         "transaction_location_pid": loc_public_martigny.pid,
         "transaction_user_pid": librarian_martigny.pid,
     }
-    item, actions = item.extend_loan(**params)
-    assert item.status == ItemStatus.ON_LOAN
-    extended_loan = Loan.get_record_by_pid(initial_loan.pid)
+    frozen_now = datetime.now(timezone.utc)
+    with freeze_time(frozen_now):
+        item, actions = item.extend_loan(**params)
+        assert item.status == ItemStatus.ON_LOAN
+        extended_loan = Loan.get_record_by_pid(initial_loan.pid)
 
-    expected_date = datetime.now() + timedelta(days=cipo["renewal_duration"])
-    expected_date_eve = expected_date - timedelta(days=1)
-    expected_date = lib_martigny.next_open(expected_date_eve)
+        now_lib_tz = datetime.now(timezone.utc).astimezone(lib_martigny.get_timezone())
+        expected_date = now_lib_tz + timedelta(days=cipo["renewal_duration"])
+        expected_date_eve = expected_date - timedelta(days=1)
+        expected_date = lib_martigny.next_open(expected_date_eve)
 
-    ext_end_date = ciso8601.parse_datetime(str(extended_loan.end_date))
-    assert expected_date.strftime("%Y%m%d") == ext_end_date.strftime("%Y%m%d")
+        ext_end_date = ciso8601.parse_datetime(str(extended_loan.end_date))
+        assert expected_date.strftime("%Y%m%d") == ext_end_date.strftime("%Y%m%d")
 
     # Reset the application configuration
     app.config["CIRCULATION_POLICIES"]["extension"] = settings

tests/ui/circulation/test_extend_external.py

@@ -74,9 +74,12 @@ def test_item_loans_extend_duration(
                 utc_end_date = now + duration
                 # computed end date at the library timezone
                 end_date = utc_end_date.astimezone(tz=lib_martigny.get_timezone())
-                expected_utc_end_date = now + timedelta(days=policy["renewal_duration"])
-                # expected end date at the library timezone
-                expected_end_date = expected_utc_end_date.astimezone(lib_martigny.get_timezone())
+                # Mirror the next_open logic used by get_extension_params so
+                # the comparison is consistent across timezone/day boundaries.
+                now_lib_tz = now.astimezone(lib_martigny.get_timezone())
+                renewal_duration = policy["renewal_duration"]
+                expected_due_eve = now_lib_tz + timedelta(days=renewal_duration - 1)
+                expected_end_date = lib_martigny.next_open(expected_due_eve)
                 assert end_date.strftime("%Y-%m-%d") == expected_end_date.strftime("%Y-%m-%d")
                 assert end_date.hour == 23
                 assert end_date.minute == 59

tests/ui/libraries/test_libraries_api.py

@@ -68,19 +68,20 @@ def next_weekday(d, weekday):
 
     # CASE 1 :: basic tests. According to library settings:
     #   * monday --> friday  :: 6 AM  --> closed
-    #   * monday --> friday  :: 12 AM --> open
+    #   * monday --> friday  :: 12 PM --> open
     #   * saturday & sunday  :: closed all day
+    # Datetimes are localized to the library timezone so opening-hour
+    # comparisons are not skewed by a UTC offset.
+    tz = library.get_timezone()
     orginal_date = datetime.strptime("2020/08/17", "%Y/%m/%d")  # random date
     for day_idx in range(5):
         test_date = next_weekday(orginal_date, day_idx)
-        test_date = test_date.replace(hour=6, minute=0)
-        assert not library.is_open(test_date)
-        test_date = test_date.replace(hour=12)
-        assert library.is_open(test_date)
+        assert not library.is_open(tz.localize(test_date.replace(hour=6, minute=0)))
+        assert library.is_open(tz.localize(test_date.replace(hour=12, minute=0)))
     test_date = next_weekday(orginal_date, 5)
-    assert not library.is_open(test_date)
+    assert not library.is_open(tz.localize(test_date))
     test_date = next_weekday(orginal_date, 6)
-    assert not library.is_open(test_date)
+    assert not library.is_open(tz.localize(test_date))
 
     # CASE 2 :: Check single exception dates
     #   * According to library setting, the '2018-12-15' day is an exception