¿Cómo monopatch python datetime.datetime.now con py.test?

mocking

Question

Necesito probar funciones que usan datetime.datetime.now() . ¿Cuál es la forma más fácil de hacer esto?

Answer 1

Necesitas la función monkeytime de datetime.now. En el siguiente ejemplo, estoy creando un accesorio que puedo volver a usar más tarde en otras pruebas:

import datetime
import pytest

FAKE_TIME = datetime.datetime(2020, 12, 25, 17, 05, 55)

@pytest.fixture
def patch_datetime_now(monkeypatch):

    class mydatetime:
        @classmethod
        def now(cls):
            return FAKE_TIME

    monkeypatch.setattr(datetime, ''datetime'', mydatetime)


def test_patch_datetime(patch_datetime_now):
    assert datetime.datetime.now() == FAKE_TIME

Answer 2

Este es el accesorio que utilizo para anular ahora () pero manteniendo el resto del trabajo de fecha y hora (pregunta de RE: satoru).

No está ampliamente probado, pero soluciona los problemas donde se usa datetime en otros contextos. Para mí, esto era importante para mantener el ORM de Django trabajando con estos valores de fecha y hora (Específicamente es isinstance(Freeze.now(), datetime.datetime) == True ).

@pytest.fixture
def freeze(monkeypatch):
    """ Now() manager patches datetime return a fixed, settable, value
        (freezes time)
    """
    import datetime
    original = datetime.datetime

    class FreezeMeta(type):
        def __instancecheck__(self, instance):
            if type(instance) == original or type(instance) == Freeze:
                return True

    class Freeze(datetime.datetime):
        __metaclass__ = FreezeMeta

        @classmethod
        def freeze(cls, val):
            cls.frozen = val

        @classmethod
        def now(cls):
            return cls.frozen

        @classmethod
        def delta(cls, timedelta=None, **kwargs):
            """ Moves time fwd/bwd by the delta"""
            from datetime import timedelta as td
            if not timedelta:
                timedelta = td(**kwargs)
            cls.frozen += timedelta

    monkeypatch.setattr(datetime, ''datetime'', Freeze)
    Freeze.freeze(original.now())
    return Freeze

Tal vez fuera del tema, pero podría ser útil para otras personas que llegan a esta pregunta. Este accesorio permite el tiempo de "congelación" y luego lo mueve hacia adelante y hacia atrás según lo desee en sus pruebas:

def test_timesensitive(freeze):
    freeze.freeze(2015, 1, 1)
    foo.prepare()  # Uses datetime.now() to prepare its state
    freeze.delta(days=2)
    # Does something that takes in consideration that 2 days have passed
    # i.e. datetime.now() returns a date 2 days in the future
    foo.do_something()
    assert foo.result == expected_result_after_2_days

Answer 3

Hay freezegun módulo freezegun :

from datetime import datetime
from freezegun import freeze_time # $ pip install freezegun

@freeze_time("Jan 14th, 2012")
def test_nice_datetime():
    assert datetime.now() == datetime(2012, 1, 14)

freeze_time() también se puede usar como administrador de contexto. El soporte del módulo que especifica el desplazamiento UTC de la zona horaria local.

Answer 4

Adaptado de las otras respuestas:

import datetime as dt

@contextmanager
def mocked_now(now):
    class MockedDatetime(dt.datetime):
        @classmethod
        def now(cls):
            return now

    with patch("datetime.datetime", MockedDatetime):
        yield

Usado como:

def test_now():
    with mocked_now(dt.datetime(2017, 10, 21)):
        assert dt.datetime.now() == dt.datetime(2017, 10, 21)