Mencoba untuk mengejek datetime.date.today (), tetapi tidak berfungsi

Adakah yang bisa memberi tahu saya mengapa ini tidak berhasil?

>>> import mock
>>> @mock.patch('datetime.date.today')
... def today(cls):
...  return date(2010, 1, 1)
...
>>> from datetime import date
>>> date.today()
datetime.date(2010, 12, 19)

Mungkin seseorang bisa menyarankan cara yang lebih baik?

Ada beberapa masalah.

Pertama-tama, cara Anda menggunakan mock.patchtidak sepenuhnya benar. Ketika digunakan sebagai dekorator, ia menggantikan fungsi / kelas yang diberikan (dalam hal ini, datetime.date.today) dengan Mockobjek hanya dalam fungsi yang didekorasi . Jadi, hanya di dalam Anda today()akan datetime.date.todayfungsi yang berbeda, yang tampaknya tidak seperti yang Anda inginkan.

Apa yang sebenarnya Anda inginkan tampaknya lebih seperti ini:

@mock.patch('datetime.date.today')
def test():
    datetime.date.today.return_value = date(2010, 1, 1)
    print datetime.date.today()

Sayangnya, ini tidak akan berhasil:

>>> test()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "build/bdist.macosx-10.6-universal/egg/mock.py", line 557, in patched
  File "build/bdist.macosx-10.6-universal/egg/mock.py", line 620, in __enter__
TypeError: can't set attributes of built-in/extension type 'datetime.date'

Ini gagal karena tipe bawaan Python tidak dapat diubah - lihat jawaban ini untuk lebih jelasnya.

Dalam hal ini, saya akan membuat subclass datetime.date sendiri dan membuat fungsi yang tepat:

import datetime
class NewDate(datetime.date):
    @classmethod
    def today(cls):
        return cls(2010, 1, 1)
datetime.date = NewDate

Dan sekarang Anda bisa melakukannya:

>>> datetime.date.today()
NewDate(2010, 1, 1)

Opsi lain adalah menggunakan https://github.com/spulec/freezegun/

Pasang itu:

pip install freezegun

Dan gunakan itu:

from freezegun import freeze_time

@freeze_time("2012-01-01")
def test_something():

    from datetime import datetime
    print(datetime.now()) #  2012-01-01 00:00:00

    from datetime import date
    print(date.today()) #  2012-01-01

Ini juga memengaruhi panggilan datetime lainnya dalam panggilan metode dari modul lain:

other_module.py:

from datetime import datetime

def other_method():
    print(datetime.now())    

main.py:

from freezegun import freeze_time

@freeze_time("2012-01-01")
def test_something():

    import other_module
    other_module.other_method()

Dan akhirnya:

$ python main.py
# 2012-01-01

Untuk apa nilainya, dokumen Mock berbicara tentang datetime.date.today khusus, dan mungkin untuk melakukan ini tanpa harus membuat kelas dummy:

https://docs.python.org/3/library/unittest.mock-examples.html#partial-mocking

>>> from datetime import date
>>> with patch('mymodule.date') as mock_date:
...     mock_date.today.return_value = date(2010, 10, 8)
...     mock_date.side_effect = lambda *args, **kw: date(*args, **kw)
...
...     assert mymodule.date.today() == date(2010, 10, 8)
...     assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)
...

Saya kira saya datang sedikit terlambat untuk ini tetapi saya pikir masalah utama di sini adalah bahwa Anda menambal datetime.date.today secara langsung dan, menurut dokumentasi, ini salah.

Anda harus menambal referensi yang diimpor dalam file tempat fungsi yang diuji, misalnya.

Katakanlah Anda memiliki file functions.py di mana Anda memiliki yang berikut ini:

import datetime

def get_today():
    return datetime.date.today()

maka, dalam ujian Anda, Anda harus memiliki sesuatu seperti ini

import datetime
import unittest

from functions import get_today
from mock import patch, Mock

class GetTodayTest(unittest.TestCase):

    @patch('functions.datetime')
    def test_get_today(self, datetime_mock):
        datetime_mock.date.today = Mock(return_value=datetime.strptime('Jun 1 2005', '%b %d %Y'))
        value = get_today()
        # then assert your thing...

Semoga ini bisa membantu sedikit.

Untuk menambah solusi Daniel G :

from datetime import date

class FakeDate(date):
    "A manipulable date replacement"
    def __new__(cls, *args, **kwargs):
        return date.__new__(date, *args, **kwargs)

Ini menciptakan kelas yang, ketika dipakai, akan mengembalikan objek datetime.date yang normal, tetapi yang juga bisa diubah.

@mock.patch('datetime.date', FakeDate)
def test():
    from datetime import date
    FakeDate.today = classmethod(lambda cls: date(2010, 1, 1))
    return date.today()

test() # datetime.date(2010, 1, 1)

Saya menghadapi situasi yang sama beberapa hari yang lalu, dan solusi saya adalah mendefinisikan fungsi dalam modul untuk diuji dan hanya mengejek itu:

def get_date_now():
    return datetime.datetime.now()

Hari ini saya mengetahuinya FreezeGun , dan sepertinya menutupi kasus ini dengan indah

from freezegun import freeze_time
import datetime
import unittest


@freeze_time("2012-01-14")
def test():
    assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)

Cara termudah bagi saya adalah melakukan ini:

import datetime
from unittest.mock import Mock, patch

def test():
    datetime_mock = Mock(wraps=datetime.datetime)
    datetime_mock.now.return_value = datetime.datetime(1999, 1, 1)
    with patch('datetime.datetime', new=datetime_mock):
        assert datetime.datetime.now() == datetime.datetime(1999, 1, 1)

PERHATIAN untuk solusi ini: semua fungsi dari datetime moduledari target_moduleakan berhenti bekerja.

Anda dapat menggunakan pendekatan berikut, berdasarkan pada solusi Daniel G. Yang satu ini memiliki keuntungan tidak melanggar jenis memeriksa isinstance(d, datetime.date).

import mock

def fixed_today(today):
    from datetime import date

    class FakeDateType(type):
        def __instancecheck__(self, instance):
            return isinstance(instance, date)

    class FakeDate(date):
        __metaclass__ = FakeDateType

        def __new__(cls, *args, **kwargs):
            return date.__new__(date, *args, **kwargs)

        @staticmethod
        def today():
            return today

    return mock.patch("datetime.date", FakeDate)

Pada dasarnya, kami mengganti datetime.datekelas berbasis-C dengan subclass python kami sendiri, yang menghasilkan datetime.dateinstance asli dan menjawab isinstance()pertanyaan persis seperti aslidatetime.date .

Gunakan itu sebagai manajer konteks dalam pengujian Anda:

with fixed_today(datetime.date(2013, 11, 22)):
    # run the code under test
    # note, that these type checks will not break when patch is active:
    assert isinstance(datetime.date.today(), datetime.date)

Pendekatan serupa dapat digunakan untuk mengejek datetime.datetime.now()fungsi.

Secara umum, Anda akan memiliki datetimeatau mungkindatetime.date diimpor ke modul di suatu tempat. Cara yang lebih efektif untuk memperolok metode ini adalah dengan menambalnya pada modul yang mengimpornya. Contoh:

a.py

from datetime import date

def my_method():
    return date.today()

Kemudian untuk pengujian Anda, objek tiruan itu sendiri akan diteruskan sebagai argumen ke metode pengujian. Anda akan mengatur tiruan dengan nilai hasil yang Anda inginkan, dan kemudian memanggil metode Anda dalam pengujian. Maka Anda akan menegaskan bahwa metode Anda melakukan apa yang Anda inginkan.

>>> import mock
>>> import a
>>> @mock.patch('a.date')
... def test_my_method(date_mock):
...     date_mock.today.return_value = mock.sentinel.today
...     result = a.my_method()
...     print result
...     date_mock.today.assert_called_once_with()
...     assert mock.sentinel.today == result
...
>>> test_my_method()
sentinel.today

Sebuah kata peringatan. Sangat mungkin untuk pergi ke laut dengan mengejek. Ketika Anda melakukannya, itu membuat tes Anda lebih lama, lebih sulit untuk dipahami, dan tidak mungkin untuk dipertahankan. Sebelum Anda mengejek metode sesederhana datetime.date.today, tanyakan pada diri Anda apakah Anda benar - benar perlu mengejeknya. Jika pengujian Anda singkat dan langsung ke sasaran dan berfungsi dengan baik tanpa mengejek fungsi, Anda mungkin hanya melihat detail internal kode yang Anda uji daripada objek yang perlu Anda tiru.

Berikut cara lain untuk mengejek datetime.date.today()dengan bonus tambahan yang sisa datetimefungsi terus bekerja, karena objek tiruan dikonfigurasi untuk membungkus datetimemodul asli :

from unittest import mock, TestCase

import foo_module

class FooTest(TestCase):

    @mock.patch(f'{foo_module.__name__}.datetime', wraps=datetime)
    def test_something(self, mock_datetime):
        # mock only datetime.date.today()
        mock_datetime.date.today.return_value = datetime.date(2019, 3, 15)
        # other calls to datetime functions will be forwarded to original datetime

Perhatikan wraps=datetimeargumen untuk mock.patch()- ketika foo_modulemenggunakan datetimefungsi lain selain date.today()mereka akan diteruskan ke datetimemodul yang dibungkus asli .

Beberapa solusi dibahas di http://blog.xelnor.net/python-mocking-datetime/ . Singkatnya:

Objek tiruan - Sederhana dan efisien tetapi merusak isinstance () memeriksa:

target = datetime.datetime(2009, 1, 1)
with mock.patch.object(datetime, 'datetime', mock.Mock(wraps=datetime.datetime)) as patched:
    patched.now.return_value = target
    print(datetime.datetime.now())

Kelas tiruan

import datetime
import mock

real_datetime_class = datetime.datetime

def mock_datetime_now(target, dt):
    class DatetimeSubclassMeta(type):
        @classmethod
        def __instancecheck__(mcs, obj):
            return isinstance(obj, real_datetime_class)

    class BaseMockedDatetime(real_datetime_class):
        @classmethod
        def now(cls, tz=None):
            return target.replace(tzinfo=tz)

        @classmethod
        def utcnow(cls):
            return target

    # Python2 & Python3 compatible metaclass
    MockedDatetime = DatetimeSubclassMeta('datetime', (BaseMockedDatetime,), {})

    return mock.patch.object(dt, 'datetime', MockedDatetime)

Digunakan sebagai:

with mock_datetime_now(target, datetime):
   ....

Mungkin Anda bisa menggunakan metode "today ()" Anda sendiri yang akan Anda tempel di tempat yang diperlukan. Contoh dengan mengejek utcnow () dapat ditemukan di sini: https://bitbucket.org/k_bx/blog/src/tip/source/en_posts/2012-07-13-double-call-hack.rst?at=default

Saya menerapkan metode @ user3016183 menggunakan dekorator khusus:

def changeNow(func, newNow = datetime(2015, 11, 23, 12, 00, 00)):
    """decorator used to change datetime.datetime.now() in the tested function."""
    def retfunc(self):                             
        with mock.patch('mymodule.datetime') as mock_date:                         
            mock_date.now.return_value = newNow
            mock_date.side_effect = lambda *args, **kw: datetime(*args, **kw)
            func(self)
    return retfunc

Saya pikir itu mungkin membantu seseorang suatu hari ...

Dimungkinkan untuk mengejek fungsi datetime modul tanpa menambahkanside_effects

import mock
from datetime import datetime
from where_datetime_used import do

initial_date = datetime.strptime('2018-09-27', "%Y-%m-%d")
with mock.patch('where_datetime_used.datetime') as mocked_dt:
    mocked_dt.now.return_value = initial_date
    do()

Bagi Anda yang menggunakan pytest dengan mocker di sini adalah bagaimana saya mengejek datetime.datetime.now()yang sangat mirip dengan pertanyaan aslinya.

test_get_now(mocker):
    datetime_mock = mocker.patch("blackline_accounts_import.datetime",)
    datetime_mock.datetime.now.return_value=datetime.datetime(2019,3,11,6,2,0,0)

    now == function_being_tested()  # run function

    assert now == datetime.datetime(2019,3,11,6,2,0,0)

Pada dasarnya tiruan harus diatur untuk mengembalikan tanggal yang ditentukan. Anda tidak dapat menambal objek datetime secara langsung.

Saya membuat pekerjaan ini dengan mengimpor datetimesebagai realdatetimedan mengganti metode yang saya butuhkan di tiruan dengan metode nyata:

import datetime as realdatetime

@mock.patch('datetime')
def test_method(self, mock_datetime):
    mock_datetime.today = realdatetime.today
    mock_datetime.now.return_value = realdatetime.datetime(2019, 8, 23, 14, 34, 8, 0)

Anda dapat mengejek datetimemenggunakan ini:

Dalam modul sources.py:

import datetime


class ShowTime:
    def current_date():
        return datetime.date.today().strftime('%Y-%m-%d')

Di Anda tests.py:

from unittest import TestCase, mock
import datetime


class TestShowTime(TestCase):
    def setUp(self) -> None:
        self.st = sources.ShowTime()
        super().setUp()

    @mock.patch('sources.datetime.date')
    def test_current_date(self, date_mock):
        date_mock.today.return_value = datetime.datetime(year=2019, month=10, day=1)
        current_date = self.st.current_date()
        self.assertEqual(current_date, '2019-10-01')

CPython benar-benar mengimplementasikan modul datetime menggunakan Lib / datetime.py -Python murni dan Modul C-dioptimalkan / _datetimemodule.c . Versi C-dioptimalkan tidak dapat ditambal tetapi versi pure-Python bisa.

Di bagian bawah implementasi pure-Python di Lib / datetime.py adalah kode ini:

try:
    from _datetime import *  # <-- Import from C-optimized module.
except ImportError:
    pass

Kode ini mengimpor semua definisi C-dioptimalkan dan secara efektif menggantikan semua definisi pure-Python. Kita bisa memaksa CPython untuk menggunakan implementasi murni-Python dari modul datetime dengan melakukan:

import datetime
import importlib
import sys

sys.modules["_datetime"] = None
importlib.reload(datetime)

Dengan menetapkan sys.modules["_datetime"] = None, kami memberi tahu Python untuk mengabaikan modul yang dioptimalkan-C. Kemudian kami memuat kembali modul yang menyebabkan impor dari_datetime gagal. Sekarang definisi pure-Python tetap dan dapat ditambal secara normal.

Jika Anda menggunakan Pytest maka sertakan cuplikan di atas di conftest.py dan Anda dapat menambal datetimeobjek secara normal.