How can I test a function that depends on the current time?

Make the time an input to the decision you want to test. For example, instead of having an is_expired function ask the system for the time, pass it both the deadline and the time to compare against. The surrounding application can get the current time with datetime.now(); Python documents that this returns the current local date and time when no timezone is supplied. [S1]

The key is that the test does not call now(). It chooses a fixed time and passes it in, so the expected answer does not depend on when the test runs. This example intentionally keeps the comparison simple:

from datetime import datetime


def is_expired(deadline: datetime, now: datetime) -> bool:
    return now >= deadline

The function has one clear job: compare two supplied values. The code that chooses the time is outside it.

Use fixed values for the deadline and the time being checked. Then test the moment just before the deadline, the deadline itself, and a moment after it. Those cases make the chosen rule—expired at the deadline or only afterward—visible. Here, >= means that equality counts as expired.

import unittest
from datetime import datetime

from expiry import is_expired


class IsExpiredTests(unittest.TestCase):
    def test_before_deadline_is_not_expired(self):
        deadline = datetime(2030, 5, 1, 12, 0)
        now = datetime(2030, 5, 1, 11, 59)
        self.assertFalse(is_expired(deadline, now))

    def test_at_deadline_is_expired(self):
        deadline = datetime(2030, 5, 1, 12, 0)
        now = datetime(2030, 5, 1, 12, 0)
        self.assertTrue(is_expired(deadline, now))

    def test_after_deadline_is_expired(self):
        deadline = datetime(2030, 5, 1, 12, 0)
        now = datetime(2030, 5, 1, 12, 1)
        self.assertTrue(is_expired(deadline, now))

Replace expiry with the name of your module. The test values are examples, not a claim about any real deadline. Keep the boundary expectation aligned with the behavior your program is meant to implement.

Keep reading the clock at the edge of the application, then pass the result to the calculation. For example:

from datetime import datetime
from expiry import is_expired


def check_expiry(deadline: datetime) -> bool:
    current_time = datetime.now()
    return is_expired(deadline, current_time)

Now the comparison is independently testable, while check_expiry connects it to the real clock. If you also need to test code that calls check_expiry, consider passing in a clock callable, such as a function that returns a datetime. The real application can supply a callable that reads the clock; a test can supply one that returns a chosen value.

Avoid reading the clock in multiple places for a single decision. Capturing one value and passing it through makes it clear which instant that decision uses. The example uses local time because it calls datetime.now() without a timezone argument. This guide does not establish what timezone or time representation is appropriate for your application; choose that deliberately for your use case.

Start by identifying the exact rule that depends on time, then make that rule accept its time as an input. Write tests for both sides of the boundary and the boundary itself. If production code needs to obtain time, keep that responsibility separate and pass the value—or a clock callable—to the rule.

A reusable mini-template is:

def decision(deadline, now):
    # Put the time-dependent rule here.
    return now >= deadline


def test_decision():
    deadline = ...  # chosen test value
    now = ...       # chosen test value
    assert decision(deadline, now) is ...

For tests using unittest, replace the final assertion with an appropriate self.assertTrue(...) or self.assertFalse(...). The example covers a direct comparison only; it does not decide how your application should handle timezones, daylight-saving transitions, or invalid inputs. Those requirements need their own explicit design choices and tests.