Тестване на Python Django: TestCase срещу TransactionTestCase

Тестването е решаващ аспект от разработката на софтуер, като гарантира, че вашето приложение се държи според очакванията и остава стабилно с течение на времето. Django, популярна Python уеб рамка, предоставя мощна рамка за тестване, която да ви помогне да пишете ефективни тестове. Тази публикация в блога ще се задълбочи в два основни класа в рамките на тестовата рамка на Django: TestCase и TransactionTestCase. Ще проучим техните разлики, случаи на употреба и ще предоставим практически примери, за да ви помогнем да изберете правилния клас за вашите нужди от тестване.

Защо тестването е важно в Django

Преди да се потопим в спецификите на TestCase и TransactionTestCase, нека накратко обсъдим защо тестването е толкова важно в разработката на Django:

• Осигурява качество на кода: Тестовете ви помагат да уловите грешки в началото на процеса на разработка, като ги предпазвате от влизане в производство.
• Улеснява рефакторирането: С изчерпателен набор от тестове можете уверено да рефакторирате кода си, знаейки, че тестовете ще ви предупредят, ако въведете някакви регресии.
• Подобрява сътрудничеството: Добре написаните тестове служат като документация за вашия код, което улеснява другите разработчици да разберат и да допринесат.
• Поддържа разработка, базирана на тестове (TDD): TDD е подход за разработка, при който пишете тестове преди да напишете действителния код. Това ви принуждава да мислите за желаното поведение на вашето приложение предварително, което води до по-чист и по-лесен за поддръжка код.

Тестовата рамка на Django: Бърз преглед

Тестовата рамка на Django е изградена върху вградения в Python модул unittest. Той предоставя няколко функции, които улесняват тестването на приложенията на Django, включително:

• Откриване на тестове: Django автоматично открива и изпълнява тестове във вашия проект.
• Тестов изпълнител: Django предоставя тестов изпълнител, който изпълнява вашите тестове и отчита резултатите.
• Методи за твърдение: Django предоставя набор от методи за твърдение, които можете да използвате, за да проверите очакваното поведение на вашия код.
• Клиент: Тестовият клиент на Django ви позволява да симулирате взаимодействията на потребителите с вашето приложение, като например изпращане на формуляри или правене на API заявки.
• TestCase и TransactionTestCase: Това са двата основни класа за писане на тестове в Django, които ще разгледаме подробно.

TestCase: Бързо и ефективно единично тестване

TestCase е основният клас за писане на unit тестове в Django. Той предоставя чиста среда на база данни за всеки тестов случай, като гарантира, че тестовете са изолирани и не си влияят взаимно.

Как работи TestCase

Когато използвате TestCase, Django извършва следните стъпки за всеки тестов метод:

1. Създава тестова база данни: Django създава отделна тестова база данни за всяко тестване.
2. Изчиства базата данни: Преди всеки тестов метод Django изчиства тестовата база данни, като премахва всички съществуващи данни.
3. Изпълнява тестов метод: Django изпълнява тествания метод, който сте дефинирали.
4. Връща транзакцията: След всеки метод за тестване Django връща транзакцията, ефективно отменяйки всички промени, направени в базата данни по време на тестването.

Този подход гарантира, че всеки тестов метод започва с чисто платно и че всички промени, направени в базата данни, автоматично се връщат. Това прави TestCase идеален за единично тестване, където искате да тествате отделни компоненти на вашето приложение изолирано.

Пример: Тестване на прост модел

Нека разгледаме прост пример за тестване на модел Django с помощта на TestCase:

from django.test import TestCase
from .models import Product

class ProductModelTest(TestCase):
 def test_product_creation(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(product.name, "Test Product")
 self.assertEqual(product.price, 10.00)
 self.assertTrue(isinstance(product, Product))

В този пример тестваме създаването на екземпляр на модела Product. Методът test_product_creation създава нов продукт и след това използва методи за твърдение, за да провери дали атрибутите на продукта са зададени правилно.

Кога да използвате TestCase

TestCase обикновено е предпочитаният избор за повечето сценарии за тестване на Django. Той е бърз, ефективен и осигурява чиста среда на база данни за всеки тест. Използвайте TestCase, когато:

• Тествате отделни модели, изгледи или други компоненти на вашето приложение.
• Искате да гарантирате, че вашите тестове са изолирани и не си влияят взаимно.
• Не е необходимо да тествате сложни взаимодействия с бази данни, които обхващат множество транзакции.

TransactionTestCase: Тестване на сложни взаимодействия с бази данни

TransactionTestCase е друг клас за писане на тестове в Django, но той се различава от TestCase по начина, по който обработва транзакциите на базата данни. Вместо да връща транзакцията след всеки тестов метод, TransactionTestCase потвърждава транзакцията. Това го прави подходящ за тестване на сложни взаимодействия с база данни, които обхващат множество транзакции, като тези, включващи сигнали или атомарни транзакции.

Как работи TransactionTestCase

Когато използвате TransactionTestCase, Django извършва следните стъпки за всеки тестов случай:

1. Създава тестова база данни: Django създава отделна тестова база данни за всяко тестване.
2. НЕ изчиства базата данни: TransactionTestCase *не* автоматично изчиства базата данни преди всеки тест. Очаква базата данни да е в последователно състояние преди всеки тест да бъде изпълнен.
3. Изпълнява тестов метод: Django изпълнява тествания метод, който сте дефинирали.
4. Потвърждава транзакцията: След всеки тестов метод Django потвърждава транзакцията, правейки промените постоянни в тестовата база данни.
5. Прекъсва таблиците: В *края* на всички тестове в TransactionTestCase, таблиците се съкращават, за да се изчистят данните.

Тъй като TransactionTestCase потвърждава транзакцията след всеки метод за тестване, важно е да се уверите, че вашите тестове не оставят базата данни в непоследователно състояние. Може да се наложи ръчно да почистите всички данни, създадени по време на тестването, за да избегнете намеса в последващите тестове.

Пример: Тестване на сигнали

Нека разгледаме пример за тестване на сигнали на Django с помощта на TransactionTestCase:

from django.test import TransactionTestCase
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product, ProductLog

@receiver(post_save, sender=Product)
def create_product_log(sender, instance, created, **kwargs):
 if created:
 ProductLog.objects.create(product=instance, action="Created")

class ProductSignalTest(TransactionTestCase):
 def test_product_creation_signal(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(ProductLog.objects.count(), 1)
 self.assertEqual(ProductLog.objects.first().product, product)
 self.assertEqual(ProductLog.objects.first().action, "Created")

В този пример тестваме сигнал, който създава екземпляр ProductLog винаги, когато се създава нов екземпляр Product. Методът test_product_creation_signal създава нов продукт и след това проверява дали е създаден съответният запис в регистрационния файл на продукта.

Кога да използвате TransactionTestCase

TransactionTestCase обикновено се използва в специфични сценарии, когато трябва да тествате сложни взаимодействия с бази данни, които обхващат множество транзакции. Обмислете използването на TransactionTestCase, когато:

• Тествате сигнали, които се задействат от операции с база данни.
• Тествате атомарни транзакции, които включват множество операции с база данни.
• Трябва да проверите състоянието на базата данни след поредица от свързани операции.
• Използвате код, който разчита на автоматично увеличаващ се идентификатор, който да се запази между тестовете (макар че това обикновено се счита за лоша практика).

Важни съображения при използване на TransactionTestCase

Тъй като TransactionTestCase потвърждава транзакциите, важно е да сте наясно със следните съображения:

• Почистване на базата данни: Може да се наложи ръчно да почистите всички данни, създадени по време на тестването, за да избегнете намеса в последващите тестове. Обмислете използването на методи setUp и tearDown за управление на тестовите данни.
• Изолация на тестове: TransactionTestCase не предоставя същото ниво на изолация на тестовете като TestCase. Бъдете внимателни за потенциални взаимодействия между тестовете и се уверете, че вашите тестове не разчитат на състоянието на базата данни от предишни тестове.
• Производителност: TransactionTestCase може да бъде по-бавен от TestCase, защото включва потвърждаване на транзакции. Използвайте го преценливо и само когато е необходимо.

Най-добри практики за тестване на Django

Ето някои най-добри практики, които трябва да имате предвид при писане на тестове в Django:

• Пишете ясни и кратки тестове: Тестовете трябва да са лесни за разбиране и поддръжка. Използвайте описателни имена за тестови методи и твърдения.
• Тествайте по едно нещо в даден момент: Всеки тестов метод трябва да се фокусира върху тестването на един аспект от вашия код. Това улеснява идентифицирането на източника на повреда, когато тестът не успее.
• Използвайте смислени твърдения: Използвайте методи за твърдение, които ясно изразяват очакваното поведение на вашия код. Django предоставя богат набор от методи за твърдение за различни сценарии.
• Следвайте модела Arrange-Act-Assert: Структурирайте своите тестове според модела Arrange-Act-Assert: Подредете тестовите данни, Действайте върху тествания код и Утвърдете очаквания резултат.
• Поддържайте тестовете си бързи: Бавните тестове могат да разубедят разработчиците да ги изпълняват често. Оптимизирайте тестовете си, за да намалите времето за изпълнение.
• Използвайте фикстури за тестови данни: Фикстурите са удобен начин за зареждане на първоначални данни във вашата тестова база данни. Използвайте фикстури, за да създадете последователни и многократни тестови данни. Помислете за използване на естествени ключове във фикстурите, за да избегнете хардкодиране на идентификатори.
• Помислете за използването на тестова библиотека като pytest: Докато вградената тестова рамка на Django е мощна, библиотеки като pytest могат да предложат допълнителни функции и гъвкавост.
• Стремете се към високо тестово покритие: Стремете се към високо тестово покритие, за да се уверите, че вашият код е напълно тестван. Използвайте инструменти за покритие, за да измерите тестовото си покритие и да идентифицирате области, които се нуждаят от повече тестване.
• Интегрирайте тестове във вашия CI/CD pipeline: Изпълнявайте автоматично тестовете си като част от вашия процес за непрекъсната интеграция и непрекъснато внедряване (CI/CD). Това гарантира, че всички регресии се откриват рано в процеса на разработка.
• Напишете тестове, които отразяват реални сценарии: Тествайте приложението си по начини, които имитират начина, по който потребителите действително ще взаимодействат с него. Това ще ви помогне да откриете грешки, които може да не са очевидни в простите unit тестове. Например, помислете за вариациите в международните адреси и телефонни номера при тестване на формуляри.

Интернационализация (i18n) и тестване

При разработване на приложения на Django за глобална аудитория е от решаващо значение да се вземе предвид интернационализацията (i18n) и локализацията (l10n). Уверете се, че вашите тестове покриват различни езици, формати на дати и валутни символи. Ето няколко съвета:

• Тествайте с различни езикови настройки: Използвайте декоратора override_settings на Django, за да тествате приложението си с различни езикови настройки.
• Използвайте локализирани данни във вашите тестове: Използвайте локализирани данни във вашите тестови фикстури и тестови методи, за да сте сигурни, че приложението ви обработва правилно различни формати на дати, валутни символи и други данни, специфични за локала.
• Тествайте вашите преводни низове: Проверете дали вашите преводни низове са правилно преведени и дали се изобразяват правилно на различни езици.
• Използвайте етикета за шаблон localize: Във вашите шаблони използвайте етикета за шаблон localize, за да форматирате дати, числа и други данни, специфични за локала, според текущия локал на потребителя.

Пример: Тестване с различни езикови настройки

from django.test import TestCase
from django.utils import translation
from django.conf import settings

class InternationalizationTest(TestCase):

 def test_localized_date_format(self):
 original_language = translation.get_language()
 try:
 translation.activate('de') # Activate German language
 with self.settings(LANGUAGE_CODE='de'): # Set the language in settings
 from django.utils import formats
 from datetime import date
 d = date(2024, 1, 20)
 formatted_date = formats.date_format(d, 'SHORT_DATE_FORMAT')
 self.assertEqual(formatted_date, '20.01.2024')
 finally:
 translation.activate(original_language) # Restore original language

Този пример демонстрира как да тествате форматирането на дати с различни езикови настройки, използвайки модулите translation и formats на Django.

Заключение

Разбирането на разликите между TestCase и TransactionTestCase е от съществено значение за писането на ефективни и надеждни тестове в Django. TestCase обикновено е предпочитаният избор за повечето сценарии за тестване, предоставяйки бърз и ефективен начин за тестване на отделни компоненти на вашето приложение изолирано. TransactionTestCase е полезен за тестване на сложни взаимодействия с база данни, които обхващат множество транзакции, като тези, включващи сигнали или атомарни транзакции. Като следвате най-добрите практики и като вземете предвид аспектите на интернационализацията, можете да създадете стабилен набор от тестове, който гарантира качеството и поддръжката на вашите приложения Django.

Допълнително обучение

• Django Testing Documentation
• Python unittest Documentation
• pytest Documentation