Django: есть ли способ подсчитать SQL-запросы из модульного теста?

Начиная с Django 1.3 существует assertNumQueries Доступно именно для этой цели.

Ответ Виная правильный, с одним небольшим дополнением.

Среда модульного тестирования Django фактически устанавливает DEBUG в False при запуске, поэтому независимо от того, что у вас есть в settings.py, у вас не будет ничего заполненного в connection.queries в вашем модульном тесте, если вы снова не включите режим отладки. Документы Django объясняют обоснование этого следующим образом:

Независимо от значения параметра DEBUG в вашем файле конфигурации, все тесты Django выполняются с DEBUG=False. Это делается для того, чтобы наблюдаемый результат вашего кода соответствовал тому, что будет видно в рабочей среде.

Если вы уверены, что включение отладки не повлияет на ваши тесты (например, если вы специально тестируете попадания в БД, как это звучит), решение состоит в том, чтобы временно повторно включить отладку в вашем модульном тесте, а затем установить его обратно потом:

def test_myself(self):
    from django.conf import settings
    from django.db import connection

    settings.DEBUG = True
    connection.queries = []

    # Test code as normal
    self.assert_(connection.queries)

    settings.DEBUG = False

Если вы используете pytest, pytest-django имеет django_assert_num_queries приспособление для этой цели:

def test_queries(django_assert_num_queries):
    with django_assert_num_queries(3):
        Item.objects.create('foo')
        Item.objects.create('bar')
        Item.objects.create('baz')

Если вы не хотите использовать TestCase (с assertNumQueries) или измените настройки на DEBUG=True, вы можете использовать контекстный менеджер CaptureQueriesContext (такой же, как assertNumQueries с использованием).

from django.db import ConnectionHandler
from django.test.utils import CaptureQueriesContext

DB_NAME = "default"  # name of db configured in settings you want to use - "default" is standard
connection = ConnectionHandler()[DB_NAME]
with CaptureQueriesContext(connection) as context:
    ... # do your thing
num_queries = context.initial_queries - context.final_queries
assert num_queries == expected_num_queries

настройки БД

В современном Django (>=1.8) это хорошо документировано (также документировано для 1.7) здесь у вас есть метод reset_queries вместо назначения connection.queries=[] который действительно вызывает ошибку, что-то подобное работает на django>=1.8:

class QueriesTests(django.test.TestCase):
    def test_queries(self):
        from django.conf import settings
        from django.db import connection, reset_queries

        try:
            settings.DEBUG = True
            # [... your ORM code ...]
            self.assertEquals(len(connection.queries), num_of_expected_queries)
        finally:
            settings.DEBUG = False
            reset_queries()

Вы также можете сбросить запросы в setUp/tearDown, чтобы убедиться, что запросы сбрасываются для каждого теста, а не делать это в предложении finally, но этот способ более явный (хотя и более подробный), или вы можете использовать reset_queries в предложении try столько раз, сколько вам нужно для оценки запросов, начиная с 0.

Если у вас DEBUG установлено значение True в вашем settings.py (предположительно, так и в вашей тестовой среде), вы можете подсчитывать запросы, выполненные в вашем тесте, следующим образом:

from django.db import connection

class DoSomethingTests(django.test.TestCase):
    def test_something_or_other(self):
        num_queries_old = len(connection.queries)
        do_something_in_the_database()
        num_queries_new = len(connection.queries)
        self.assertEqual(n, num_queries_new - num_queries_old)

Вот рабочий прототип менеджера контекста с AssertNumQueriesLessThan.

import json
from contextlib import contextmanager
from django.test.utils import CaptureQueriesContext
from django.db import connections

@contextmanager
def withAssertNumQueriesLessThan(self, value, using='default', verbose=False):
    with CaptureQueriesContext(connections[using]) as context:
        yield   # your test will be run here
    if verbose:
        msg = "\r\n%s" % json.dumps(context.captured_queries, indent=4)
    else:
        msg = None
    self.assertLess(len(context.captured_queries), value, msg=msg)

Его можно просто использовать в ваших модульных тестах, например, для проверки количества запросов на вызов Django REST API.

    with self.withAssertNumQueriesLessThan(10):
        response = self.client.get('contacts/')
        self.assertEqual(response.status_code, 200)

Также вы можете предоставить точные БД using и verbose, если вы хотите красиво распечатать список фактических запросов на стандартный вывод

Если вы хотите использовать для этого декоратор, есть приятный смысл:

import functools
import sys
import re
from django.conf import settings
from django.db import connection

def shrink_select(sql):
    return re.sub("^SELECT(.+)FROM", "SELECT .. FROM", sql)

def shrink_update(sql):
    return re.sub("SET(.+)WHERE", "SET .. WHERE", sql)

def shrink_insert(sql):
    return re.sub("\((.+)\)", "(..)", sql)

def shrink_sql(sql):
    return shrink_update(shrink_insert(shrink_select(sql)))

def _err_msg(num, expected_num, verbose, func=None):
    func_name = "%s:" % func.__name__ if func else ""
    msg = "%s Expected number of queries is %d, actual number is %d.\n" % (func_name, expected_num, num,)
    if verbose > 0:
        queries = [query['sql'] for query in connection.queries[-num:]]
        if verbose == 1:
            queries = [shrink_sql(sql) for sql in queries]
        msg += "== Queries == \n" +"\n".join(queries)
    return msg


def assertNumQueries(expected_num, verbose=1):

    class DecoratorOrContextManager(object):
        def __call__(self, func):  # decorator
            @functools.wraps(func)
            def inner(*args, **kwargs):
                handled = False
                try:
                    self.__enter__()
                    return func(*args, **kwargs)
                except:
                    self.__exit__(*sys.exc_info())
                    handled = True
                    raise
                finally:
                    if not handled:
                        self.__exit__(None, None, None)
            return inner

        def __enter__(self):
            self.old_debug = settings.DEBUG
            self.old_query_count = len(connection.queries)
            settings.DEBUG = True

        def __exit__(self, type, value, traceback):
            if not type:
                num = len(connection.queries) - self.old_query_count
                assert expected_num == num, _err_msg(num, expected_num, verbose)
            settings.DEBUG = self.old_debug

    return DecoratorOrContextManager()