Datetime.date.today () ile alay etmeye çalışıyor, ancak çalışmıyor

Biri bana bunun neden çalışmadığını söyleyebilir mi?

>>> 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)

Belki biri daha iyi bir yol önerebilir?

Birkaç sorun var.

Her şeyden önce, kullanma şekliniz mock.patchdoğru değil. Dekoratör olarak kullanıldığında, verilen işlevi / sınıfı (bu durumda datetime.date.today) yalnızca dekore edilmiş işlev içindeki bir Mocknesneyle değiştirir . Yani, sadece içinde senin olacak ne istediğinizi olmak görünmüyor, farklı bir fonksiyon olmak.today()datetime.date.today

Gerçekten istediğiniz şey daha çok gibi görünüyor:

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

Ne yazık ki, bu işe yaramaz:

>>> 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'

Python yerleşik türleri değiştirilemez olduğu için bu başarısız olur - daha fazla ayrıntı için bu cevaba bakın.

Bu durumda, ben datetime.date kendimi alt sınıf ve doğru işlevi oluşturmak:

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

Ve şimdi şunları yapabilirsiniz:

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

Başka bir seçenek https://github.com/spulec/freezegun/ kullanmaktır

Yükle:

pip install freezegun

Ve kullanın:

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

Ayrıca, diğer modüllerden yöntem çağrılarındaki diğer datetime çağrılarını da etkiler:

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()

Ve sonunda:

$ python main.py
# 2012-01-01

Değer için, Mock belgeleri datetime.date.today hakkında özellikle konuşur ve bunu bir kukla sınıf oluşturmak zorunda kalmadan yapmak mümkündür:

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)
...

Sanırım bunun için biraz geç geldim ama burada asıl sorun datetime.date.today'a doğrudan yama uyguladığınız ve belgelere göre bu yanlış olduğunu düşünüyorum.

Örneğin, test edilen işlevin bulunduğu dosyaya içe aktarılan referansı yamalamanız gerekir.

Diyelim ki aşağıdakilere sahip bir function.py dosyanız var:

import datetime

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

testinizde böyle bir şeye sahip olmalısınız

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...

Umarım bu biraz yardımcı olur.

Daniel G'nin çözümüne eklemek için :

from datetime import date

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

Bu, somutlaştırıldığında normal datetime.date nesnesini döndürecek, ancak değiştirilebilen bir sınıf oluşturur.

@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)

Birkaç gün önce aynı durumla karşı karşıya kaldım ve çözümüm, test etmek ve sadece alay etmek için modüldeki bir işlevi tanımlamaktı:

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

Bugün FreezeGun'u öğrendim ve bu davayı güzel bir şekilde ele alıyor gibi görünüyor

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)

Benim için en kolay yol bunu yapmak:

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)

Bu çözüm için DİKKAT: Tüm işlevsellik datetime modulegelen target_moduledurduracak çalışma.

Daniel G çözümüne dayalı olarak aşağıdaki yaklaşımı kullanabilirsiniz. Bu, tip kontrolünü kırmama avantajına sahiptir 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)

Temel olarak, C tabanlı datetime.datesınıfı, özgün datetime.dateörnekler üreten ve isinstance()sorgulara tam olarak yerel olarak yanıt veren kendi python alt sınıfımızla değiştiriyoruz datetime.date.

Testlerinizde içerik yöneticisi olarak kullanın:

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)

Benzer yaklaşım, datetime.datetime.now()işlev alay etmek için kullanılabilir .

Genel anlamda, olurdu datetimeya da belki datetime.datebir modül yerde ithal. Yöntemin atılmasının daha etkili bir yolu, onu içe aktarılan modüle yapıştırmak olacaktır. Misal:

a.py

from datetime import date

def my_method():
    return date.today()

Daha sonra testiniz için, sahte nesnenin kendisi test yöntemine argüman olarak geçirilir. Sahte, istediğiniz sonuç değeri ile ayarlamak ve sonra test yönteminizi çağırmak. O zaman yönteminizin istediğinizi yaptığını iddia edersiniz.

>>> 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

Uyarı kelimesi. Kesinlikle alay ile denize girmek mümkündür. Bunu yaptığınızda, testlerinizi daha uzun, anlaşılması daha zor ve bakımı imkansız hale getirir. Ne kadar basit bir yöntemle alay etmeden önce datetime.date.today, gerçekten alay etmeniz gerekip gerekmediğini kendinize sorun . Testiniz kısa ve noktaya geldiyse ve işlev alay etmeden iyi çalışıyorsa, taklit etmeniz gereken bir nesne yerine test ettiğiniz kodun dahili bir ayrıntısına bakıyor olabilirsiniz.

Sahte nesne orijinal modülü sarmak için yapılandırıldığından, işlevlerin datetime.date.today()geri kalanının datetimeçalışmaya devam ettiği ek bir bonusla alay etmenin başka bir yolu datetime:

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

- dışında diğer işlevleri kullandığında , orijinal sarılmış modüle iletilecek wraps=datetimeargümanı not edin .mock.patch()foo_moduledatetimedate.today()datetime

Çeşitli çözümler http://blog.xelnor.net/python-mocking-datetime/ adresinde tartışılmaktadır . Özetle:

Sahte nesne - Basit ve verimli ancak isinstance () kontrollerini keser:

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())

Sahte sınıf

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)

Kullanım şekli:

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

Belki de ihtiyaç duyduğunuz yerde yama yapacağınız kendi "today ()" yönteminizi kullanabilirsiniz. Alaycı utcnow () örneği burada bulunabilir: https://bitbucket.org/k_bx/blog/src/tip/source/en_posts/2012-07-13-double-call-hack.rst?at=default

Özel bir dekoratör kullanarak @ user3016183 yöntemini uyguladım:

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

Bunun bir gün birine yardım edebileceğini düşündüm ...

Eklemeksizin datetimemodülden fonksiyonları taklit etmek mümkündürside_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()

Mocker ile pytest kullananlarınız için burada datetime.datetime.now()orijinal soruya çok benzeyen alay ettim .

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)

Temelde alay belirtilen tarihi geri döndürecek şekilde ayarlanmalıdır. Doğrudan datetime nesnesini yamalayamazsınız.

Ben ithal ederek bu işi yapılmış datetimeolarak realdatetimeve gerçek yöntemlerle taklidinin gerekli yöntemleri yerine:

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)

Bunu kullanarak alay edebilirsiniz datetime:

Modülde sources.py:

import datetime


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

Sizin 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 aslında saf-Python Lib / datetime.py ve C-optimize Modüller / _datetimemodule.c'yi kullanarak datetime modülünü uygular . C optimizasyonlu sürüm yamalanamaz ancak salt Python sürümü kullanılabilir.

Lib / datetime.py dosyasındaki pure-Python uygulamasının altında şu kod yer alır:

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

Bu kod, C için optimize edilmiş tüm tanımları alır ve tüm pure-Python tanımlarının yerini alır. CPython'u datetime modülünün pure-Python uygulamasını kullanmaya zorlayabiliriz:

import datetime
import importlib
import sys

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

Ayarlayarak sys.modules["_datetime"] = NonePython'a C optimizasyon modülünü yoksaymasını söyleriz. Daha sonra içe aktarma _datetimeişleminin başarısız olmasına neden olan modülü yeniden yüklüyoruz. Şimdi saf Python tanımları kalır ve normal olarak yamalanabilir.

Pytest kullanıyorsanız yukarıdaki snippet'i conftest.py dosyasına ekleyin ve datetimenesneleri normal şekilde yatırabilirsiniz .