使用 django-cacheops，我想测试我的 View 是否按照我的预期进行了缓存。在我的测试用例中，我将 cacheops cache_read 信号连接到一个处理程序，该处理程序应该为命中或未命中增加缓存中的值。但是，信号永远不会被触发。有谁知道在测试用例中连接 django 信号处理程序的正确方法，纯粹用于该测试用例？

这是我目前所拥有的

from cacheops.signals import cache_read

cache.set('test_cache_hits', 0)
cache.set('test_cache_misses', 0)

def cache_log(sender, func, hit, **kwargs):
    # never called
    if hit:
        cache.incr('test_cache_hits')
    else:
        cache.incr('test_cache_misses')


class BootstrapTests(TestCase):

    @classmethod
    def setUpClass(cls):
        super(BootstrapTests, cls).setUpClass()
        cache_read.connect(cache_log)
        assert cache_read.has_listeners()

    def test_something_that_should_fill_and_retrieve_cache(self):
        ....
        hits = cache.get('test_cache_hits') # always 0

我还尝试在模块级别和常规测试用例 setUp 方法中连接信号处理程序，所有结果都相同。

编辑: 这是我的实际测试代码，加上我正在测试的对象。我正在使用 cached_as 装饰器来缓存一个函数。此测试当前失败。

boostrap.py

class BootstrapData(object):

    def __init__(self, app, person=None):
        self.app = app

    def get_homepage_dict(self, context={}):

        url_name = self.app.url_name

        @cached_as(App.objects.filter(url_name=url_name), extra=context)
        def _get_homepage_dict():
            if self.app.homepage is None:
                return None

            concrete_module_class = MODULE_MAPPING[self.app.homepage.type]
            serializer_class_name = f'{concrete_module_class.__name__}Serializer'
            serializer_class = getattr(api.serializers, serializer_class_name)
            concrete_module = concrete_module_class.objects.get(module=self.app.homepage)
            serializer = serializer_class(context=context)
            key = concrete_module_class.__name__
            return {
                key: serializer.to_representation(instance=concrete_module)
            }
        return _get_homepage_dict()

test_bootstrap.py

class BootstrapDataTest(TestCase):

    def setUp(self):
        super(BootstrapDataTest, self).setUp()

        def set_signal(signal=None, **kwargs):
            self.signal_calls.append(kwargs)
        self.signal_calls = []
        cache_read.connect(set_signal, dispatch_uid=1, weak=False)
        self.app = self.setup_basic_app() # creates an 'App' model and saves it

    def tearDown(self):
        cache_read.disconnect(dispatch_uid=1)

    def test_boostrap_data_is_cached(self):

        obj = BootstrapData(self.app)
        obj.get_homepage_dict()

        # fails, self.signal_calls == []
        self.assertEqual(self.signal_calls, [{'sender': App, 'func': None, 'hit': False }])

        self.signal_calls = []

        obj.get_homepage_dict()
        self.assertEqual(self.signal_calls, [{'sender': App, 'func': None, 'hit': True}])

最佳答案

我不明白为什么会这样，但无论如何我都会尝试给出一个有用的答案。

首先，如果你想测试缓存是否有效，你不应该依赖它自己的副作用来检查它，信号是它的主要功能的副作用 - 防止数据库调用。尝试测试:

def test_it_works(self):
    with self.assertNumQueries(1):
        obj.get_homepage_dict()

    with self.assertNumQueries(0):
        obj.get_homepage_dict()

其次，如果你想知道发生了什么，你可以深入研究在任何地方添加打印，包括 cacheops 代码，看看它在哪里停止。或者，你可以做个测试让我看看，说明在这里https://github.com/Suor/django-cacheops#writing-a-test .

最后，你的测试有点错误。对于 @cached_as() sender 将是 None 并且 func 将是修饰函数。

关于python - 在测试中连接 Django 信号处理程序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44821010/