Come monkeypatch python's datetime.datetime.now con py.test?

Question

Ho bisogno di testare funzioni che utilizzano datetime.datetime.now(). Qual è il modo più semplice per farlo?

Answer 1

È necessario eseguire il monkeypatch della funzione datetime.now. Nell'esempio qui di seguito, sto creando apparecchio che posso riutilizzare successivamente in altri test:

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

Questo è il dispositivo che uso per superiori ora(), ma mantenendo il resto del datetime di lavoro (RE: la domanda di Satoru).

Non viene testato estesamente, ma risolve i problemi in cui viene utilizzato datetime in altri contesti. Per me è stato importante mantenere il Django ORM lavorando con questi valori datetime (in particolare 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 

Forse fuori tema, ma potrebbe tornare utile ad altre persone che arrivano a questa domanda. Questo dispositivo permette di "congelare" il tempo, e poi si spostano avanti e indietro a piacimento entro i test:

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

C'è freezegun module:

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() potrebbe essere utilizzato anche come un contesto manager. Il supporto del modulo che specifica l'offset UTC del fuso orario locale.

Answer 4

Adattato dalle altre risposte:

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 

Usato come:

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