unittest.md

1> **Источник:** https://python-all.ru/3.4/library/unittest.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 26.3. [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) – Фреймворк для модульного тестирования89(Если вы уже знакомы с основными понятиями тестирования, можете перейти к [*списку методов assert*](https://python-all.ru/3.4/library/unittest.html#assert-methods).)1011Фреймворк для модульного тестирования [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) изначально был вдохновлён JUnit и по духу близок к основным фреймворкам модульного тестирования на других языках. Он поддерживает автоматизацию тестов, совместное использование кода настройки и завершения для тестов, объединение тестов в коллекции, а также независимость тестов от фреймворка для составления отчётов.1213Для этого [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) поддерживает несколько важных концепций в объектно-ориентированном стиле:1415**тестовая фикстура**1617*Тестовая фикстура*1819представляет собой подготовку, необходимую для выполнения одного или нескольких тестов, и любые сопутствующие действия по очистке. Это может включать, например, создание временных или прокси-баз данных, каталогов или запуск серверного процесса.2021**тестовый случай**2223*Тестовый пример*2425– это отдельная единица тестирования. Он проверяет конкретную реакцию на определённый набор входных данных.2627[`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest)2829предоставляет базовый класс3031[`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase)3233, который можно использовать для создания новых тестовых примеров.3435**набор тестов**3637*Набор тестов*3839– это совокупность тестовых случаев, наборов тестов или и того, и другого. Он используется для объединения тестов, которые должны выполняться вместе.4041**исполнитель тестов**4243*Исполнитель тестов*4445– это компонент, который управляет выполнением тестов и предоставляет результат пользователю. Исполнитель может использовать графический интерфейс, текстовый интерфейс или возвращать специальное значение, указывающее на результаты выполнения тестов.4647> **См. также**48>49> **Модуль [`doctest`](https://python-all.ru/3.4/library/doctest.html#module-doctest)**50>51> Ещё один модуль поддержки тестирования с совершенно другим подходом.52>53> **[Простое тестирование в Smalltalk: с шаблонами](https://python-all.ru/3.4/library/unittest.html)**54>55> Оригинальная статья Кента Бека о фреймворках тестирования, использующих шаблон, общий для56>57> [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest)58>59> .60>61> **[Nose](https://python-all.ru/3.4/library/unittest.html) и [py.test](https://python-all.ru/3.4/library/unittest.html)**62>63> Сторонние фреймворки unittest с более лёгким синтаксисом для написания тестов. Например,64>65> `assert func(10) == 42`66>67> .68>69> **[Таксономия инструментов тестирования Python](https://python-all.ru/3.4/library/unittest.html)**70>71> Обширный список инструментов тестирования Python, включая фреймворки функционального тестирования и библиотеки имитационных объектов (mock).72>73> **[Список рассылки по тестированию в Python](https://python-all.ru/3.4/library/unittest.html)**74>75> Группа по интересам для обсуждения тестирования и инструментов тестирования в Python.76>77> Скрипт `Tools/unittestgui/unittestgui.py` в дистрибутиве исходного кода Python – это инструмент с графическим интерфейсом для обнаружения и выполнения тестов. Он предназначен в первую очередь для упрощения работы тех, кто только знакомится с модульным тестированием. Для производственных сред рекомендуется запускать тесты с помощью системы непрерывной интеграции, такой как [Buildbot](https://python-all.ru/3.4/library/unittest.html), [Jenkins](https://python-all.ru/3.4/library/unittest.html) или [Hudson](https://python-all.ru/3.4/library/unittest.html).7879## 26.3.1. Простой пример8081Модуль [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) предоставляет богатый набор инструментов для создания и запуска тестов. В этом разделе показано, что даже небольшого подмножества этих инструментов достаточно для удовлетворения потребностей большинства пользователей.8283Вот короткий скрипт для тестирования трёх строковых методов:8485```python86import unittest8788class TestStringMethods(unittest.TestCase):8990  def test_upper(self):91      self.assertEqual('foo'.upper(), 'FOO')9293  def test_isupper(self):94      self.assertTrue('FOO'.isupper())95      self.assertFalse('Foo'.isupper())9697  def test_split(self):98      s = 'hello world'99      self.assertEqual(s.split(), ['hello', 'world'])100      # проверить, что s.split завершается ошибкой, если разделитель не строка101      with self.assertRaises(TypeError):102          s.split(2)103104if __name__ == '__main__':105    unittest.main()106```107108Тестовый пример создаётся путём создания подкласса [`unittest.TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase). Три отдельных теста определяются методами, имена которых начинаются с букв `test`. Это соглашение об именах сообщает программе запуска тестов, какие методы представляют собой тесты.109110Суть каждого теста – вызов [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual) для проверки ожидаемого результата; [`assertTrue()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertTrue) или [`assertFalse()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertFalse) для проверки условия; или [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises) для проверки того, что возникает определённое исключение. Эти методы используются вместо оператора [`assert`](https://python-all.ru/3.4/reference/simple_stmts.html#assert), чтобы программа запуска тестов могла накапливать все результаты и формировать отчёт.111112Методы [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) и [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown) позволяют определить инструкции, которые будут выполняться до и после каждого тестового метода. Они подробно рассматриваются в разделе [*Организация тестового кода*](https://python-all.ru/3.4/library/unittest.html#organizing-tests).113114Последний блок демонстрирует простой способ запуска тестов. [`unittest.main()`](https://python-all.ru/3.4/library/unittest.html#unittest.main) предоставляет интерфейс командной строки для тестового скрипта. При запуске из командной строки указанный скрипт выдаёт вывод, который выглядит так:115116```python117...118----------------------------------------------------------------------119Ran 3 tests in 0.000s120121OK122```123124Передача параметра `-v` тестовому скрипту укажет [`unittest.main()`](https://python-all.ru/3.4/library/unittest.html#unittest.main) включить более высокий уровень подробности и выдать следующий вывод:125126```python127test_isupper (__main__.TestStringMethods) ... ok128test_split (__main__.TestStringMethods) ... ok129test_upper (__main__.TestStringMethods) ... ok130131----------------------------------------------------------------------132Ran 3 tests in 0.001s133134OK135```136137Приведённые выше примеры показывают наиболее часто используемые возможности [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest), которых достаточно для удовлетворения многих повседневных потребностей тестирования. В остальной части документации подробно рассматривается полный набор возможностей, начиная с основ.138139## 26.3.2. Интерфейс командной строки140141Модуль unittest можно использовать из командной строки для запуска тестов из модулей, классов или даже отдельных тестовых методов:142143```python144python -m unittest test_module1 test_module2145python -m unittest test_module.TestClass146python -m unittest test_module.TestClass.test_method147```148149Можно передать список с любой комбинацией имён модулей, а также полных имён классов или методов.150151Тестовые модули также можно указывать по пути к файлу:152153```python154python -m unittest tests/test_something.py155```156157Это позволяет использовать автодополнение имён файлов в оболочке для указания тестового модуля. Указанный файл по-прежнему должен быть импортируем как модуль. Путь преобразуется в имя модуля путём удаления ‘.py’ и замены разделителей пути на ‘.’. Если требуется выполнить тестовый файл, который не импортируется как модуль, следует запускать файл напрямую.158159Можно запускать тесты с большей детализацией (повышенной подробностью), передав флаг -v:160161```python162python -m unittest -v test_module163```164165При запуске без аргументов запускается [*автоматическое обнаружение тестов*](https://python-all.ru/3.4/library/unittest.html#unittest-test-discovery):166167```python168python -m unittest169```170171Чтобы получить список всех параметров командной строки:172173```python174python -m unittest -h175```176177Изменено в версии 3.2: В более ранних версиях можно было запускать только отдельные тестовые методы, а не модули или классы.178179### 26.3.2.1. Параметры командной строки180181**unittest** поддерживает следующие параметры командной строки:182183#### `-b, --buffer`184185Потоки стандартного вывода и стандартной ошибки буферизируются во время выполнения теста. Вывод при успешном тесте отбрасывается. При ошибке или провале теста вывод выводится обычным образом и добавляется к сообщениям о неудаче.186187#### `-c, --catch`188189`Control-C` во время выполнения теста ожидает завершения текущего теста, а затем сообщает все результаты на данный момент. Второе нажатие `Control-C` вызывает обычное исключение [`KeyboardInterrupt`](https://python-all.ru/3.4/library/exceptions.html#KeyboardInterrupt).190191См. раздел [Обработка сигналов](https://python-all.ru/3.4/library/unittest.html#signal-handling) с описанием функций, предоставляющих эту возможность.192193#### `-f, --failfast`194195Остановить выполнение теста при первой же ошибке или неудаче.196197Новое в версии 3.2: Были добавлены параметры командной строки `-b`, `-c` и `-f`.198199Командная строка также может использоваться для автоматического обнаружения тестов, для запуска всех тестов в проекте или только их части.200201## 26.3.3. Обнаружение тестов202203Новое в версии 3.2.204205Unittest поддерживает простой поиск тестов. Чтобы тесты были совместимы с поиском, все тестовые файлы должны быть [*модулями*](https://python-all.ru/3.4/tutorial/modules.html#tut-modules) или [*пакетами*](https://python-all.ru/3.4/tutorial/modules.html#tut-packages) (включая [*пространственные пакеты*](https://python-all.ru/3.4/glossary.html#term-namespace-package)), которые можно импортировать из корневого каталога проекта (это означает, что их имена файлов должны быть допустимыми [*идентификаторами*](https://python-all.ru/3.4/reference/lexical_analysis.html#identifiers)).206207Обнаружение тестов реализовано в [`TestLoader.discover()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.discover), но также может использоваться из командной строки. Основное использование в командной строке:208209```python210cd project_directory211python -m unittest discover212```213214> **Примечание**215>216> В качестве сокращения `python -m unittest` эквивалентно `python -m unittest discover`. Если требуется передать аргументы для обнаружения тестов, подкоманду `discover` необходимо указывать явно.217218Подкоманда `discover` имеет следующие параметры:219220#### `-v, --verbose`221222Подробный вывод223224#### `-s, --start-directory directory`225226Каталог для начала обнаружения (по умолчанию `.`)227228#### `-p, --pattern pattern`229230Шаблон для сопоставления тестовых файлов (по умолчанию `test*.py`)231232#### `-t, --top-level-directory directory`233234Корневой каталог проекта (по умолчанию – каталог начала поиска)235236Параметры [*-s*](https://python-all.ru/3.4/library/unittest.html#cmdoption-unittest-discover-s), [*-p*](https://python-all.ru/3.4/library/unittest.html#cmdoption-unittest-discover-p) и [*-t*](https://python-all.ru/3.4/library/unittest.html#cmdoption-unittest-discover-t) можно передавать в качестве позиционных аргументов в указанном порядке. Следующие две командные строки эквивалентны:237238```python239python -m unittest discover -s project_directory -p "*_test.py"240python -m unittest discover project_directory "*_test.py"241```242243Помимо пути можно передать имя пакета, например `myproject.subpackage.test`, в качестве начального каталога. Указанное имя пакета будет импортировано, а его расположение в файловой системе будет использовано как начальный каталог.244245> **Внимание**246>247> Обнаружение тестов загружает тесты путём их импорта. Когда обнаружение найдёт все тестовые файлы в указанном начальном каталоге, оно преобразует пути в имена пакетов для импорта. Например, `foo/bar/baz.py` будет импортирован как `foo.bar.baz`.248>249> Если пакет установлен глобально, и предпринимается попытка обнаружения тестов в другой копии пакета, то импорт *может* произойти из неправильного места. Если это произойдет, обнаружение тестов выдаст предупреждение и завершится.250>251> Если указать начальный каталог как имя пакета, а не путь к каталогу, то discover считает, что местоположение, из которого он импортирует, и есть то, которое вы имели в виду, поэтому предупреждение не появится.252253Тестовые модули и пакеты могут настраивать загрузку и обнаружение тестов с помощью [протокола load\_tests](https://python-all.ru/3.4/library/unittest.html#load-tests-protocol).254255Изменено в версии 3.4: Обнаружение тестов поддерживает [*пакеты с пространством имен*](https://python-all.ru/3.4/glossary.html#term-namespace-package).256257## 26.3.4. Организация тестового кода258259Основными строительными блоками модульного тестирования являются *тестовые сценарии* – отдельные сценарии, которые необходимо настроить и проверить на корректность. В [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) тестовые сценарии представлены экземплярами [`unittest.TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase). Чтобы создать собственные тестовые сценарии, нужно написать подклассы [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) или использовать [`FunctionTestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.FunctionTestCase).260261Тестовый код экземпляра [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) должен быть полностью самодостаточным, чтобы его можно было запускать как изолированно, так и в произвольной комбинации с любым количеством других тестовых сценариев.262263Простейший подкласс [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) просто реализует тестовый метод (т.е. метод, имя которого начинается с `test`) для выполнения конкретного тестового кода:264265```python266import unittest267268class DefaultWidgetSizeTestCase(unittest.TestCase):269    def test_default_widget_size(self):270        widget = Widget('The widget')271        self.assertEqual(widget.size(), (50, 50))272```273274Обратите внимание, что для проверки чего-либо используются методы `assert*()`, предоставляемые базовым классом [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase). Если тест не пройден, будет возбуждено исключение, и [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) определит тестовый сценарий как *неудачу*. Любые другие исключения будут рассматриваться как *ошибки*.275276Тестов может быть много, и их настройка может быть повторяющейся. К счастью, можно вынести код настройки, реализовав метод [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp), который тестовый фреймворк будет автоматически вызывать для каждого запускаемого теста:277278```python279import unittest280281class SimpleWidgetTestCase(unittest.TestCase):282    def setUp(self):283        self.widget = Widget('The widget')284285    def test_default_widget_size(self):286        self.assertEqual(self.widget.size(), (50,50),287                         'incorrect default size')288289    def test_widget_resize(self):290        self.widget.resize(100,150)291        self.assertEqual(self.widget.size(), (100,150),292                         'wrong size after resize')293```294295> **Примечание**296>297> Порядок выполнения различных тестов определяется сортировкой имен тестовых методов в соответствии со встроенным порядком строк.298299Если метод [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) возбуждает исключение во время выполнения теста, фреймворк сочтёт, что в тесте произошла ошибка, и тестовый метод не будет выполнен.300301Аналогично можно предоставить метод [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown), который выполняет очистку после выполнения тестового метода:302303```python304import unittest305306class SimpleWidgetTestCase(unittest.TestCase):307    def setUp(self):308        self.widget = Widget('The widget')309310    def tearDown(self):311        self.widget.dispose()312```313314Если [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) выполнился успешно, [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown) будет запущен вне зависимости от того, успешно ли выполнился тестовый метод.315316Такое рабочее окружение для тестового кода называется *фикстурой*.317318Экземпляры тестовых сценариев группируются по тестируемым функциям. [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) предоставляет для этого механизм: *тестовый набор*, представленный классом [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest).[`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite). В большинстве случаев вызов [`unittest.main()`](https://python-all.ru/3.4/library/unittest.html#unittest.main) сделает всё правильно, соберёт все тестовые сценарии модуля и выполнит их.319320Однако, если требуется настроить сборку набора тестов, это можно сделать самостоятельно:321322```python323def suite():324    suite = unittest.TestSuite()325    suite.addTest(WidgetTestCase('test_default_size'))326    suite.addTest(WidgetTestCase('test_resize'))327    return suite328```329330Определения тестовых сценариев и тестовых наборов можно размещать в тех же модулях, что и тестируемый код (например, `widget.py`), но есть несколько преимуществ в размещении тестового кода в отдельном модуле, например `test_widget.py`:331332- Тестовый модуль можно запускать автономно из командной строки.333- Тестовый код проще отделить от поставляемого кода.334- Меньше соблазна изменять тестовый код, чтобы подогнать его под тестируемый код, без веской причины.335- Тестовый код должен изменяться гораздо реже, чем тестируемый код.336- Тестируемый код проще поддаётся рефакторингу.337- Тесты для модулей, написанных на C, всё равно должны быть в отдельных модулях – так почему бы не придерживаться этого подхода?338- Если стратегия тестирования меняется, нет необходимости изменять исходный код.339340## 26.3.5. Повторное использование старого тестового кода341342Некоторые пользователи могут обнаружить, что у них есть существующий тестовый код, который они хотели бы запускать из [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest), без преобразования каждой старой тестовой функции в подкласс [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase).343344По этой причине [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) предоставляет класс [`FunctionTestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.FunctionTestCase). Этот подкласс [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) можно использовать для обёртывания существующей тестовой функции. Также можно предоставить функции настройки и очистки.345346Рассмотрим следующую тестовую функцию:347348```python349def testSomething():350    something = makeSomething()351    assert something.name is not None352    # ...353```354355можно создать эквивалентный экземпляр тестового случая следующим образом, с опциональными методами настройки и завершения:356357```python358testcase = unittest.FunctionTestCase(testSomething,359                                     setUp=makeSomethingDB,360                                     tearDown=deleteSomethingDB)361```362363> **Примечание**364>365> Хотя [`FunctionTestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.FunctionTestCase) можно использовать для быстрого преобразования существующей тестовой базы в систему на основе [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest), этот подход не рекомендуется. Уделив время созданию правильных подклассов [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), можно значительно упростить будущий рефакторинг тестов.366367В некоторых случаях существующие тесты могут быть написаны с использованием модуля [`doctest`](https://python-all.ru/3.4/library/doctest.html#module-doctest). Если это так, [`doctest`](https://python-all.ru/3.4/library/doctest.html#module-doctest) предоставляет класс `DocTestSuite`, который может автоматически создавать экземпляры [`unittest.TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) из существующих тестов на основе [`doctest`](https://python-all.ru/3.4/library/doctest.html#module-doctest).368369## 26.3.6. Пропуск тестов и ожидаемые сбои370371Новое в версии 3.1.372373Unittest поддерживает пропуск отдельных тестовых методов и даже целых классов тестов. Кроме того, он поддерживает пометку теста как «ожидаемый сбой» – теста, который сломан и завершится неудачей, но не должен учитываться как сбой в [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult).374375Пропуск теста – это просто использование [`skip()`](https://python-all.ru/3.4/library/unittest.html#unittest.skip) [*декоратора*](https://python-all.ru/3.4/glossary.html#term-decorator) или одного из его условных вариантов.376377Базовый пропуск выглядит так:378379```python380class MyTestCase(unittest.TestCase):381382    @unittest.skip("demonstrating skipping")383    def test_nothing(self):384        self.fail("shouldn't happen")385386    @unittest.skipIf(mylib.__version__ < (1, 3),387                     "not supported in this library version")388    def test_format(self):389        # Тесты, которые работают только для определённой версии библиотеки.390        pass391392    @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")393    def test_windows_support(self):394        # код тестирования для Windows395        pass396```397398Это вывод приведённого выше примера в подробном режиме:399400```python401test_format (__main__.MyTestCase) ... skipped 'not supported in this library version'402test_nothing (__main__.MyTestCase) ... skipped 'demonstrating skipping'403test_windows_support (__main__.MyTestCase) ... skipped 'requires Windows'404405----------------------------------------------------------------------406Ran 3 tests in 0.005s407408OK (skipped=3)409```410411Классы можно пропускать так же, как методы:412413```python414@unittest.skip("showing class skipping")415class MySkippedTestCase(unittest.TestCase):416    def test_not_run(self):417        pass418```419420[`TestCase.setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) также может пропустить тест. Это полезно, когда ресурс, который необходимо настроить, недоступен.421422Ожидаемые сбои используют декоратор [`expectedFailure()`](https://python-all.ru/3.4/library/unittest.html#unittest.expectedFailure).423424```python425class ExpectedFailureTestCase(unittest.TestCase):426    @unittest.expectedFailure427    def test_fail(self):428        self.assertEqual(1, 0, "broken")429```430431Легко создать собственные декораторы пропуска, написав декоратор, который вызывает [`skip()`](https://python-all.ru/3.4/library/unittest.html#unittest.skip) для теста, когда его нужно пропустить. Этот декоратор пропускает тест, если переданный объект не имеет определённого атрибута:432433```python434def skipUnlessHasattr(obj, attr):435    if hasattr(obj, attr):436        return lambda func: func437    return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))438```439440Следующие декораторы реализуют пропуск тестов и ожидаемые сбои:441442#### `@unittest.skip(reason)`443444Безусловно пропускает декорированный тест. Параметр *reason* должен описывать причину пропуска теста.445446#### `@unittest.skipIf(condition, reason)`447448Пропустить декорированный тест, если *condition* истинно.449450#### `@unittest.skipUnless(condition, reason)`451452Пропустить декорированный тест, если *condition* не истинно.453454#### `@unittest.expectedFailure`455456Помечает тест как ожидаемый сбой. Если тест завершается ошибкой при запуске, он не учитывается как сбой.457458#### `exception unittest.SkipTest(reason)`459460Это исключение возбуждается для пропуска теста.461462Обычно можно использовать [`TestCase.skipTest()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.skipTest) или один из декораторов пропуска, вместо прямого возбуждения этого исключения.463464Для пропущенных тестов не будут выполняться [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) или [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown). Для пропущенных классов не будут выполняться [`setUpClass()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUpClass) или [`tearDownClass()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDownClass). Для пропущенных модулей не будут выполняться `setUpModule()` или `tearDownModule()`.465466## 26.3.7. Различение итераций теста с помощью подтестов467468Новое в версии 3.4.469470Когда некоторые тесты различаются лишь незначительными отличиями, например некоторыми параметрами, unittest позволяет различать их внутри тела тестового метода с помощью [`subTest()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.subTest) контекстного менеджера.471472Например, следующий тест:473474```python475class NumbersTest(unittest.TestCase):476477    def test_even(self):478        """479        Проверить, что все числа от 0 до 5 чётные.480        """481        for i in range(0, 6):482            with self.subTest(i=i):483                self.assertEqual(i % 2, 0)484```485486выдаст следующий результат:487488```python489======================================================================490FAIL: test_even (__main__.NumbersTest) (i=1)491----------------------------------------------------------------------492Traceback (most recent call last):493  File "subtests.py", line 32, in test_even494    self.assertEqual(i % 2, 0)495AssertionError: 1 != 0496497======================================================================498FAIL: test_even (__main__.NumbersTest) (i=3)499----------------------------------------------------------------------500Traceback (most recent call last):501  File "subtests.py", line 32, in test_even502    self.assertEqual(i % 2, 0)503AssertionError: 1 != 0504505======================================================================506FAIL: test_even (__main__.NumbersTest) (i=5)507----------------------------------------------------------------------508Traceback (most recent call last):509  File "subtests.py", line 32, in test_even510    self.assertEqual(i % 2, 0)511AssertionError: 1 != 0512```513514Без использования подтеста выполнение остановится после первого сбоя, и ошибку будет менее легко диагностировать, потому что значение `i` не будет отображаться:515516```python517======================================================================518FAIL: test_even (__main__.NumbersTest)519----------------------------------------------------------------------520Traceback (most recent call last):521  File "subtests.py", line 32, in test_even522    self.assertEqual(i % 2, 0)523AssertionError: 1 != 0524```525526## 26.3.8. Классы и функции527528Этот раздел подробно описывает API [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest).529530### 26.3.8.1. Тестовые случаи531532#### `class unittest.TestCase(methodName='runTest')`533534Экземпляры класса [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) представляют логические тестовые единицы в вселенной [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest). Этот класс предназначен для использования в качестве базового класса, при этом конкретные тесты реализуются конкретными подклассами. Этот класс реализует интерфейс, необходимый тестовому исполнителю для управления тестами, и методы, которые тестовый код может использовать для проверки и сообщения о различных видах ошибок.535536Каждый экземпляр [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) будет выполнять один базовый метод: метод с именем *methodName*. В большинстве случаев использования [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) вам не придётся изменять *methodName* или переопределять метод по умолчанию `runTest()`.537538Изменено в версии 3.2: [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) может быть успешно создан без предоставления *methodName*. Это упрощает эксперименты с [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) из интерактивного интерпретатора.539540Экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) предоставляют три группы методов: одна группа используется для запуска теста, другая – реализацией теста для проверки условий и сообщения об ошибках, а также некоторые запрашивающие методы, позволяющие получать информацию о самом тесте.541542Методы первой группы (выполнение теста):543544#### `setUp()`545546Метод, вызываемый для подготовки тестового оснащения. Он вызывается непосредственно перед вызовом тестового метода; любое исключение, возбуждённое этим методом, кроме [`AssertionError`](https://python-all.ru/3.4/library/exceptions.html#AssertionError) или [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest), будет считаться ошибкой, а не неудачей теста. Реализация по умолчанию ничего не делает.547548#### `tearDown()`549550Метод, вызываемый сразу после вызова тестового метода и записи результата. Он вызывается, даже если тестовый метод возбудил исключение, поэтому реализация в подклассах должна быть особенно внимательной при проверке внутреннего состояния. Любое исключение, кроме [`AssertionError`](https://python-all.ru/3.4/library/exceptions.html#AssertionError) или [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest), возбуждённое этим методом, будет считаться ошибкой, а не неудачей теста. Этот метод будет вызван только в случае успеха [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp), независимо от результата тестового метода. Реализация по умолчанию ничего не делает.551552#### `setUpClass()`553554Метод класса, вызываемый перед запуском тестов в отдельном классе. `setUpClass` вызывается с классом в качестве единственного аргумента и должен быть декорирован как [`classmethod()`](https://python-all.ru/3.4/library/functions.html#classmethod):555556```python557@classmethod558def setUpClass(cls):559    ...560```561562См. [Фикстуры классов и модулей](https://python-all.ru/3.4/library/unittest.html#class-and-module-fixtures) для получения дополнительных сведений.563564Новое в версии 3.2.565566#### `tearDownClass()`567568Метод класса, вызываемый после завершения тестов в отдельном классе. `tearDownClass` вызывается с классом в качестве единственного аргумента и должен быть декорирован как [`classmethod()`](https://python-all.ru/3.4/library/functions.html#classmethod):569570```python571@classmethod572def tearDownClass(cls):573    ...574```575576См. [Фикстуры классов и модулей](https://python-all.ru/3.4/library/unittest.html#class-and-module-fixtures) для получения дополнительных сведений.577578Новое в версии 3.2.579580#### `run(result=None)`581582Запускает тест, собирая результат в объект [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult), переданный как *result*. Если *result* опущен или равен `None`, создаётся временный объект результата (путём вызова метода [`defaultTestResult()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.defaultTestResult)) и используется. Объект результата возвращается вызывающему [`run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.run) вызывающему.583584Тот же эффект можно получить, просто вызвав экземпляр [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase).585586Изменено в версии 3.3: Предыдущие версии `run` не возвращали результат. Не возвращал его и вызов экземпляра.587588#### `skipTest(reason)`589590Вызов этого метода во время выполнения тестового метода или [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) пропускает текущий тест. См. [*Пропуск тестов и ожидаемые сбои*](https://python-all.ru/3.4/library/unittest.html#unittest-skipping) для получения дополнительной информации.591592Новое в версии 3.1.593594#### `subTest(msg=None, **params)`595596Возвращает менеджер контекста, который выполняет вложенный блок кода как подтест. *msg* и *params* – необязательные произвольные значения, отображаемые при сбое подтеста, что позволяет однозначно их идентифицировать.597598Тестовый пример может содержать любое количество объявлений подтестов, и они могут быть произвольно вложены.599600Подробнее см. [*Различение итераций тестов с помощью подтестов*](https://python-all.ru/3.4/library/unittest.html#subtests).601602Новое в версии 3.4.603604#### `debug()`605606Запускает тест без сбора результата. Это позволяет исключениям, возникшим в тесте, распространяться до вызывающего кода, и может использоваться для поддержки запуска тестов под отладчиком.607608Класс [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) предоставляет ряд методов для проверки и сообщения об ошибках, таких как:609610| Метод | Проверяет, что | Новое в |611| --- | --- | --- |612| [`assertEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual) | `a == b` |  |613| [`assertNotEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotEqual) | `a != b` |  |614| [`assertTrue(x)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertTrue) | `bool(x) is True` |  |615| [`assertFalse(x)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertFalse) | `bool(x) is False` |  |616| [`assertIs(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIs) | `a is b` | 3.1 |617| [`assertIsNot(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIsNot) | `a is not b` | 3.1 |618| [`assertIsNone(x)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIsNone) | `x is None` | 3.1 |619| [`assertIsNotNone(x)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIsNotNone) | `x is not None` | 3.1 |620| [`assertIn(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIn) | `a in b` | 3.1 |621| [`assertNotIn(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotIn) | `a not in b` | 3.1 |622| [`assertIsInstance(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIsInstance) | `isinstance(a, b)` | 3.2 |623| [`assertNotIsInstance(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotIsInstance) | `not isinstance(a, b)` | 3.2 |624625Все методы assert принимают аргумент *msg*, который, если указан, используется в качестве сообщения об ошибке при неудаче (см. также [`longMessage`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.longMessage)). Обратите внимание, что аргумент-ключевое слово *msg* можно передавать в [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises), [`assertRaisesRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaisesRegex), [`assertWarns()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarns), [`assertWarnsRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarnsRegex) только когда они используются как контекстный менеджер.626627#### `assertEqual(first, second, msg=None)`628629Проверяет, что *first* и *second* равны. Если значения не равны, тест завершится с ошибкой.630631Кроме того, если *first* и *second* имеют один и тот же тип и являются одним из list, tuple, dict, set, frozenset или str, или любым типом, который подкласс регистрирует с помощью [`addTypeEqualityFunc()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.addTypeEqualityFunc), то будет вызвана функция сравнения, специфичная для этого типа, чтобы сгенерировать более полезное сообщение об ошибке по умолчанию (см. также [*список методов для конкретных типов*](https://python-all.ru/3.4/library/unittest.html#type-specific-methods)).632633Изменено в версии 3.1: Добавлен автоматический вызов типовой функции сравнения.634635Изменено в версии 3.2: добавлена функция [`assertMultiLineEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertMultiLineEqual) как функция сравнения по умолчанию для строк.636637#### `assertNotEqual(first, second, msg=None)`638639Проверяет, что *first* и *second* не равны. Если значения равны, тест завершится с ошибкой.640641#### `assertTrue(expr, msg=None)`642643#### `assertFalse(expr, msg=None)`644645Проверяет, что *expr* истинно (или ложно).646647Обратите внимание, что это эквивалентно `bool(expr) is True`, а не `expr is True` (для последнего используйте `assertIs(expr, True)`). Этого метода также следует избегать, когда доступны более специфичные методы (например, `assertEqual(a, b)` вместо `assertTrue(a == b)`), поскольку они предоставляют лучшее сообщение об ошибке в случае неудачи.648649#### `assertIs(first, second, msg=None)`650651#### `assertIsNot(first, second, msg=None)`652653Проверяет, что *first* и *second* вычисляются (или не вычисляются) в один и тот же объект.654655Новое в версии 3.1.656657#### `assertIsNone(expr, msg=None)`658659#### `assertIsNotNone(expr, msg=None)`660661Проверяет, что *expr* равен (или не равен) None.662663Новое в версии 3.1.664665#### `assertIn(first, second, msg=None)`666667#### `assertNotIn(first, second, msg=None)`668669Проверяет, находится ли *first* в *second* (или не находится).670671Новое в версии 3.1.672673#### `assertIsInstance(obj, cls, msg=None)`674675#### `assertNotIsInstance(obj, cls, msg=None)`676677Проверяет, что *obj* является (или не является) экземпляром *cls* (который может быть классом или кортежем классов, как поддерживается функцией [`isinstance()`](https://python-all.ru/3.4/library/functions.html#isinstance)). Чтобы проверить точный тип, используйте [`assertIs(type(obj), cls)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertIs).678679Новое в версии 3.2.680681Также можно проверять генерацию исключений, предупреждений и сообщений журнала с помощью следующих методов:682683| Метод | Проверяет, что | Новое в |684| --- | --- | --- |685| [`assertRaises(exc, fun, *args, **kwds)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises) | `fun(*args, **kwds)` возбуждает *exc* |  |686| [`assertRaisesRegex(exc, r, fun, *args, **kwds)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaisesRegex) | `fun(*args, **kwds)` возбуждает *exc* и сообщение соответствует регулярному выражению *r* | 3.1 |687| [`assertWarns(warn, fun, *args, **kwds)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarns) | `fun(*args, **kwds)` возбуждает *warn* | 3.2 |688| [`assertWarnsRegex(warn, r, fun, *args, **kwds)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarnsRegex) | `fun(*args, **kwds)` возбуждает *warn* и сообщение соответствует регулярному выражению *r* | 3.2 |689| [`assertLogs(logger, level)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertLogs) | Блок `with` регистрирует сообщения в *logger* с минимальным уровнем *level* | 3.4 |690691#### `assertRaises(exception, callable, *args, **kwds)`692693#### `assertRaises(exception, msg=None)`694695Проверяет, что исключение возбуждается, когда *callable* вызывается с любыми позиционными или ключевыми аргументами, которые также передаются в [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises). Тест проходит, если возбуждается *исключение*, является ошибкой, если возбуждается другое исключение, или завершается неудачей, если исключение не возбуждено. Чтобы перехватить любую из группы исключений, можно передать кортеж, содержащий классы исключений, как *исключение*.696697Если переданы только аргументы *исключение* и, возможно, *msg*, возвращается менеджер контекста, чтобы проверяемый код можно было написать встроенно, а не в виде функции:698699```python700with self.assertRaises(SomeException):701    do_something()702```703704При использовании в качестве менеджера контекста [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises) принимает дополнительный ключевой аргумент *msg*.705706Менеджер контекста сохранит перехваченный объект исключения в своем атрибуте `исключение`. Это может быть полезно, если требуется выполнить дополнительные проверки возбужденного исключения:707708```python709with self.assertRaises(SomeException) as cm:710    do_something()711712the_exception = cm.exception713self.assertEqual(the_exception.error_code, 3)714```715716Изменено в версии 3.1: Добавлена возможность использовать [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises) в качестве менеджера контекста.717718Изменено в версии 3.2: Добавлен атрибут `исключение`.719720Изменено в версии 3.3: добавлен ключевой аргумент *msg* при использовании в качестве менеджера контекста.721722#### `assertRaisesRegex(exception, regex, callable, *args, **kwds)`723724#### `assertRaisesRegex(exception, regex, msg=None)`725726Как и [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises), но также проверяет, что *regex* соответствует строковому представлению возбужденного исключения. *regex* может быть объектом регулярного выражения или строкой, содержащей регулярное выражение, подходящей для использования в [`re.search()`](https://python-all.ru/3.4/library/re.html#re.search). Примеры:727728```python729self.assertRaisesRegex(ValueError, "invalid literal for.*XYZ'$",730                       int, 'XYZ')731```732733или:734735```python736with self.assertRaisesRegex(ValueError, 'literal'):737   int('XYZ')738```739740Новое в версии 3.1: под именем `assertRaisesRegexp`.741742Изменено в версии 3.2: Переименован в [`assertRaisesRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaisesRegex).743744Изменено в версии 3.3: добавлен ключевой аргумент *msg* при использовании в качестве менеджера контекста.745746#### `assertWarns(warning, callable, *args, **kwds)`747748#### `assertWarns(warning, msg=None)`749750Проверяет, что предупреждение генерируется, когда *callable* вызывается с любыми позиционными или ключевыми аргументами, которые также передаются в [`assertWarns()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarns). Тест проходит, если генерируется *warning*, и завершается неудачей, если нет. Любое исключение является ошибкой. Чтобы перехватить любую из группы предупреждений, можно передать кортеж, содержащий классы предупреждений, как *warnings*.751752Если указаны только *предупреждение* и, возможно, *msg*, возвращается менеджер контекста, позволяющий писать тестируемый код inline, а не в виде функции:753754```python755with self.assertWarns(SomeWarning):756    do_something()757```758759При использовании в качестве менеджера контекста [`assertWarns()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarns) принимает дополнительный именованный аргумент *msg*.760761Менеджер контекста сохраняет перехваченный объект предупреждения в своём атрибуте `warning`, а исходную строку, вызвавшую предупреждение, в атрибутах `filename` и `lineno`. Это может быть полезно, если требуется выполнить дополнительные проверки перехваченного предупреждения:762763```python764with self.assertWarns(SomeWarning) as cm:765    do_something()766767self.assertIn('myfile.py', cm.filename)768self.assertEqual(320, cm.lineno)769```770771Этот метод работает независимо от фильтров предупреждений, установленных на момент его вызова.772773Новое в версии 3.2.774775Изменено в версии 3.3: добавлен ключевой аргумент *msg* при использовании в качестве менеджера контекста.776777#### `assertWarnsRegex(warning, regex, callable, *args, **kwds)`778779#### `assertWarnsRegex(warning, regex, msg=None)`780781Аналогично [`assertWarns()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertWarns), но также проверяет, что *regex* соответствует сообщению перехваченного предупреждения. *regex* может быть объектом регулярного выражения или строкой, содержащей регулярное выражение, пригодное для использования с [`re.search()`](https://python-all.ru/3.4/library/re.html#re.search). Пример:782783```python784self.assertWarnsRegex(DeprecationWarning,785                      r'legacy_function\(\) is deprecated',786                      legacy_function, 'XYZ')787```788789или:790791```python792with self.assertWarnsRegex(RuntimeWarning, 'unsafe frobnicating'):793    frobnicate('/etc/passwd')794```795796Новое в версии 3.2.797798Изменено в версии 3.3: добавлен ключевой аргумент *msg* при использовании в качестве менеджера контекста.799800#### `assertLogs(logger=None, level=None)`801802Менеджер контекста для проверки того, что хотя бы одно сообщение зарегистрировано в *логгере* или одном из его потомков, с уровнем не ниже указанного *уровня*.803804Если указан, *logger* должен быть объектом [`logging.Logger`](https://python-all.ru/3.4/library/logging.html#logging.Logger) или строкой [`str`](https://python-all.ru/3.4/library/stdtypes.html#str), задающей имя регистратора. По умолчанию используется корневой регистратор, который перехватывает все сообщения.805806Если указан, *level* должен быть либо числовым уровнем логирования, либо его строковым эквивалентом (например, `"ERROR"` или `logging.ERROR`). По умолчанию используется `logging.INFO`.807808Тест проходит, если хотя бы одно сообщение, выпущенное внутри блока `with`, соответствует условиям *logger* и *level*; в противном случае тест не проходит.809810Объект, возвращаемый менеджером контекста, представляет собой вспомогательный объект для записи, который отслеживает соответствующие сообщения журнала. Он имеет два атрибута:811812#### `records`813814Список объектов [`logging.LogRecord`](https://python-all.ru/3.4/library/logging.html#logging.LogRecord), соответствующих перехваченным сообщениям журнала.815816#### `output`817818Список объектов [`str`](https://python-all.ru/3.4/library/stdtypes.html#str) с форматированным выводом соответствующих сообщений.819820Пример:821822```python823with self.assertLogs('foo', level='INFO') as cm:824   logging.getLogger('foo').info('first message')825   logging.getLogger('foo.bar').error('second message')826self.assertEqual(cm.output, ['INFO:foo:first message',827                             'ERROR:foo.bar:second message'])828```829830Новое в версии 3.4.831832Существуют также другие методы для выполнения более специфических проверок, например:833834| Метод | Проверяет, что | Новое в |835| --- | --- | --- |836| [`assertAlmostEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertAlmostEqual) | `round(a-b, 7) == 0` |  |837| [`assertNotAlmostEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotAlmostEqual) | `round(a-b, 7) != 0` |  |838| [`assertGreater(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertGreater) | `a > b` | 3.1 |839| [`assertGreaterEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertGreaterEqual) | `a >= b` | 3.1 |840| [`assertLess(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertLess) | `a < b` | 3.1 |841| [`assertLessEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertLessEqual) | `a <= b` | 3.1 |842| [`assertRegex(s, r)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRegex) | `r.search(s)` | 3.1 |843| [`assertNotRegex(s, r)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotRegex) | `not r.search(s)` | 3.2 |844| [`assertCountEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertCountEqual) | *a* и *b* содержат одни и те же элементы в одинаковом количестве, независимо от их порядка | 3.2 |845846#### `assertAlmostEqual(first, second, places=7, msg=None, delta=None)`847848#### `assertNotAlmostEqual(first, second, places=7, msg=None, delta=None)`849850Проверяет, что *first* и *second* приблизительно (или не приблизительно) равны, вычисляя разность, округляя до заданного числа десятичных *знаков* (по умолчанию 7) и сравнивая с нулём. Обратите внимание, что эти методы округляют значения до заданного числа *десятичных знаков* (т.е. как функция [`round()`](https://python-all.ru/3.4/library/functions.html#round)), а не до *значащих цифр*.851852Если указан *delta* вместо *places*, то разность между *first* и *second* должна быть меньше или равна (или больше) *delta*.853854Указание одновременно *delta* и *places* вызывает исключение `TypeError`.855856Изменено в версии 3.2: [`assertAlmostEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertAlmostEqual) автоматически считает почти равными объекты, которые сравниваются как равные. [`assertNotAlmostEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotAlmostEqual) автоматически завершается неудачей, если объекты сравниваются как равные. Добавлен именованный аргумент *delta*.857858#### `assertGreater(first, second, msg=None)`859860#### `assertGreaterEqual(first, second, msg=None)`861862#### `assertLess(first, second, msg=None)`863864#### `assertLessEqual(first, second, msg=None)`865866Проверяет, что *first* соответственно \>, \>=, \< или \<= по отношению к *second* в зависимости от имени метода. Если это не так, тест завершается ошибкой:867868```python869>>> self.assertGreaterEqual(3, 4)870AssertionError: "3" unexpectedly not greater than or equal to "4"871```872873Новое в версии 3.1.874875#### `assertRegex(text, regex, msg=None)`876877#### `assertNotRegex(text, regex, msg=None)`878879Проверяет, что поиск *regex* соответствует (или не соответствует) *text*. В случае неудачи сообщение об ошибке будет содержать шаблон и *text* (или шаблон и часть *text*, которая неожиданно совпала). *regex* может быть объектом регулярного выражения или строкой, содержащей регулярное выражение, пригодной для использования в [`re.search()`](https://python-all.ru/3.4/library/re.html#re.search).880881Новое в версии 3.1: под именем `assertRegexpMatches`.882883Изменено в версии 3.2: Метод `assertRegexpMatches()` переименован в [`assertRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRegex).884885Новое в версии 3.2: [`assertNotRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotRegex).886887#### `assertCountEqual(first, second, msg=None)`888889Проверяет, что последовательность *first* содержит те же элементы, что и *second*, независимо от их порядка. Если нет, генерируется сообщение об ошибке с перечислением различий между последовательностями.890891Дублирующиеся элементы *не* игнорируются при сравнении *first* и *second*. Проверяется, что каждый элемент имеет одинаковое количество в обеих последовательностях. Эквивалентно: `assertEqual(Counter(list(first)), Counter(list(second)))` но также работает с последовательностями нехэшируемых объектов.892893Новое в версии 3.2.894895Метод [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual) направляет проверку равенства для объектов одного типа к различным методам, специфичным для типа. Эти методы уже реализованы для большинства встроенных типов, но также можно зарегистрировать новые методы с помощью [`addTypeEqualityFunc()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.addTypeEqualityFunc):896897#### `addTypeEqualityFunc(typeobj, function)`898899Регистрирует метод, специфичный для типа, который вызывается [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual) для проверки, равны ли два объекта одного и того же *typeobj* (не подклассы). *function* должен принимать два позиционных аргумента и третий именованный аргумент msg=None, как и [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual). Он должен вызывать исключение [`self.failureException(msg)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.failureException) при обнаружении неравенства между первыми двумя параметрами – возможно, предоставляя полезную информацию и подробно объясняя неравенства в сообщении об ошибке.900901Новое в версии 3.1.902903Список методов, специфичных для типа, автоматически используемых [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual), приведен в следующей таблице. Обратите внимание, что обычно нет необходимости вызывать эти методы напрямую.904905| Метод | Используется для сравнения | Новое в |906| --- | --- | --- |907| [`assertMultiLineEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertMultiLineEqual) | строки | 3.1 |908| [`assertSequenceEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertSequenceEqual) | последовательности | 3.1 |909| [`assertListEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertListEqual) | списки | 3.1 |910| [`assertTupleEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertTupleEqual) | кортежи | 3.1 |911| [`assertSetEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertSetEqual) | множества или неизменяемые множества | 3.1 |912| [`assertDictEqual(a, b)`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertDictEqual) | словари | 3.1 |913914#### `assertMultiLineEqual(first, second, msg=None)`915916Проверяет, что многострочная строка *first* равна строке *second*. При неравенстве в сообщение об ошибке будет включена разница между двумя строками с выделением отличий. Этот метод используется по умолчанию при сравнении строк с [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual).917918Новое в версии 3.1.919920#### `assertSequenceEqual(first, second, msg=None, seq_type=None)`921922Проверяет, что две последовательности равны. Если передан *seq\_type*, то *first* и *second* должны быть экземплярами *seq\_type*, иначе будет вызвана ошибка. Если последовательности различаются, формируется сообщение об ошибке, показывающее разницу между ними.923924Этот метод не вызывается напрямую [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual), но используется для реализации [`assertListEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertListEqual) и [`assertTupleEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertTupleEqual).925926Новое в версии 3.1.927928#### `assertListEqual(first, second, msg=None)`929930#### `assertTupleEqual(first, second, msg=None)`931932Проверяет, что два списка или кортежа равны. Если нет, формируется сообщение об ошибке, показывающее только различия между ними. Ошибка также возникает, если какой-либо из параметров имеет неправильный тип. Эти методы используются по умолчанию при сравнении списков или кортежей с [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual).933934Новое в версии 3.1.935936#### `assertSetEqual(first, second, msg=None)`937938Проверяет, что два множества равны. Если нет, формируется сообщение об ошибке, в котором перечислены различия между множествами. Этот метод используется по умолчанию при сравнении множеств или frozensets с [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual).939940Завершается ошибкой, если *first* или *second* не имеют метода [`set.difference()`](https://python-all.ru/3.4/library/stdtypes.html#set.difference) .941942Новое в версии 3.1.943944#### `assertDictEqual(first, second, msg=None)`945946Проверяет, что два словаря равны. Если нет, формируется сообщение об ошибке, показывающее различия в словарях. Этот метод будет использоваться по умолчанию для сравнения словарей в вызовах [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual).947948Новое в версии 3.1.949950Наконец, [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) предоставляет следующие методы и атрибуты:951952#### `fail(msg=None)`953954Безусловно сообщает о провале теста, с *msg* или `None` в качестве сообщения об ошибке.955956#### `failureException`957958Этот атрибут класса задаёт исключение, возбуждаемое тестовым методом. Если тестовой платформе нужно использовать специализированное исключение, возможно, для передачи дополнительной информации, она должна создать подкласс этого исключения, чтобы корректно работать с платформой. Начальное значение этого атрибута – [`AssertionError`](https://python-all.ru/3.4/library/exceptions.html#AssertionError).959960#### `longMessage`961962Если установлено в `True`, то любое явное сообщение об ошибке, переданное в [*assert-методы*](https://python-all.ru/3.4/library/unittest.html#assert-methods), будет добавлено в конец стандартного сообщения об ошибке. Стандартные сообщения содержат полезную информацию о вовлечённых объектах, например, сообщение от assertEqual показывает repr двух неравных объектов. Установка этого атрибута в `True` позволяет иметь пользовательское сообщение об ошибке в дополнение к стандартному.963964Этот атрибут по умолчанию равен `True`. Если установлен в False, то пользовательское сообщение, переданное методу assert, подавит стандартное сообщение.965966Настройку класса можно переопределить в отдельных тестах, назначив атрибут экземпляра в `True` или `False` перед вызовом методов assert.967968Новое в версии 3.1.969970#### `maxDiff`971972Этот атрибут управляет максимальной длиной вывода различий методами assert, которые сообщают о различиях при неудаче. По умолчанию он равен 80\*8 символов. Методы assert, на которые влияет этот атрибут: [`assertSequenceEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertSequenceEqual) (включая все методы сравнения последовательностей, которые делегируют ему), [`assertDictEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertDictEqual) и [`assertMultiLineEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertMultiLineEqual).973974Установка `maxDiff` в None означает, что нет максимальной длины различий.975976Новое в версии 3.2.977978Тестовые фреймворки могут использовать следующие методы для сбора информации о тесте:979980#### `countTestCases()`981982Возвращает количество тестов, представленных этим тестовым объектом. Для экземпляров [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) это значение всегда равно `1`.983984#### `defaultTestResult()`985986Возвращает экземпляр класса результата теста, который следует использовать для этого класса тестового случая (если другой экземпляр результата не предоставлен методу [`run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.run)).987988Для экземпляров [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) это всегда будет экземпляр [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult); подклассы [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) должны переопределять это при необходимости.989990#### `id()`991992Возвращает строку, идентифицирующую конкретный тестовый случай. Обычно это полное имя тестового метода, включая имя модуля и класса.993994#### `shortDescription()`995996Возвращает описание теста или `None`, если описание не было предоставлено. Реализация по умолчанию этого метода возвращает первую строку докстринга тестового метода, если она есть, или `None`.997998Изменено в версии 3.1: В версии 3.1 это было изменено так, что имя теста добавляется в краткое описание даже при наличии докстринга. Это вызвало проблемы совместимости с расширениями unittest, и добавление имени теста было перенесено в [`TextTestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestResult) в Python 3.2.9991000#### `addCleanup(function, *args, **kwargs)`10011002Добавляет функцию, которая будет вызвана после [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown) для очистки ресурсов, используемых во время теста. Функции будут вызываться в порядке, обратном порядку их добавления (LIFO). Они вызываются с теми аргументами и именованными аргументами, которые были переданы в [`addCleanup()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.addCleanup) при их добавлении.10031004Если [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) завершается неудачей, так что [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown) не вызывается, то все добавленные функции очистки всё равно будут вызваны.10051006Новое в версии 3.1.10071008#### `doCleanups()`10091010Этот метод вызывается безусловно после [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown), или после [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp), если [`setUp()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.setUp) возбуждает исключение.10111012Он отвечает за вызов всех функций очистки, добавленных с помощью [`addCleanup()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.addCleanup). Если нужно, чтобы функции очистки вызывались *до* [`tearDown()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.tearDown), то можно вызвать [`doCleanups()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.doCleanups) самостоятельно.10131014[`doCleanups()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.doCleanups) извлекает методы из стека функций очистки по одному, поэтому его можно вызывать в любое время.10151016Новое в версии 3.1.10171018#### `class unittest.FunctionTestCase(testFunc, setUp=None, tearDown=None, description=None)`10191020Этот класс реализует часть интерфейса [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), которая позволяет тестовому раннеру управлять тестом, но не предоставляет методы, которые тестовый код может использовать для проверки и сообщения об ошибках. Он используется для создания тестовых случаев с использованием устаревшего тестового кода, позволяя интегрировать его в тестовый фреймворк на основе [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest).10211022#### 26.3.8.1.1. Устаревшие псевдонимы10231024По историческим причинам некоторые методы [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) имели один или несколько псевдонимов, которые теперь устарели. В следующей таблице перечислены правильные имена вместе с их устаревшими псевдонимами:10251026> | Имя метода | Устаревший псевдоним | Устаревший псевдоним |1027> | --- | --- | --- |1028> | [`assertEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertEqual) | failUnlessEqual | assertEquals |1029> | [`assertNotEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotEqual) | failIfEqual | assertNotEquals |1030> | [`assertTrue()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertTrue) | failUnless | assert\_ |1031> | [`assertFalse()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertFalse) | failIf |  |1032> | [`assertRaises()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaises) | failUnlessRaises |  |1033> | [`assertAlmostEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertAlmostEqual) | failUnlessAlmostEqual | assertAlmostEquals |1034> | [`assertNotAlmostEqual()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertNotAlmostEqual) | failIfAlmostEqual | assertNotAlmostEquals |1035> | [`assertRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRegex) |  | assertRegexpMatches |1036> | [`assertRaisesRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaisesRegex) |  | assertRaisesRegexp |1037>1038> Устарело с версии 3.1: псевдонимы fail\*, перечисленные во втором столбце.1039>1040> Устарело с версии 3.2: псевдонимы assert\*, перечисленные в третьем столбце.1041>1042> Устарело с версии 3.2: `assertRegexpMatches` и `assertRaisesRegexp` были переименованы в [`assertRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRegex) и [`assertRaisesRegex()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.assertRaisesRegex)10431044### 26.3.8.2. Группировка тестов10451046#### `class unittest.TestSuite(tests=())`10471048Этот класс представляет собой агрегацию отдельных тестовых случаев и тестовых наборов. Он предоставляет интерфейс, необходимый тестовому раннеру, чтобы его можно было запускать как любой другой тестовый случай. Запуск экземпляра [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) равносилен итерации по набору с запуском каждого теста по отдельности.10491050Если задан *tests*, он должен быть итерабельным объектом, содержащим отдельные тестовые примеры или другие тестовые наборы, которые будут использоваться для первоначального построения набора. Дополнительные методы предоставляются для добавления тестовых примеров и наборов в коллекцию позже.10511052Объекты [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) во многом аналогичны объектам [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), за исключением того, что они не реализуют тест напрямую. Вместо этого они служат для объединения тестов в группы, которые должны выполняться совместно. Есть несколько дополнительных методов для добавления тестов в экземпляры [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite):10531054#### `addTest(test)`10551056Добавляет объект [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) или [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) в набор.10571058#### `addTests(tests)`10591060Добавляет все тесты из итерируемого объекта, содержащего экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite), в данный тестовый набор.10611062Это эквивалентно перебору *tests* с вызовом [`addTest()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.addTest) для каждого элемента.10631064[`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) имеет общие следующие методы с [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase):10651066#### `run(result)`10671068Запускает тесты, связанные с этим набором, собирая результат в объект результата теста, переданный как *result*. Обратите внимание, что, в отличие от [`TestCase.run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase.run), [`TestSuite.run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.run) требует обязательной передачи объекта результата.10691070#### `debug()`10711072Запускает тесты, связанные с этим набором, без сбора результата. Это позволяет исключениям, возбуждённым тестом, распространяться до вызывающего кода и может использоваться для поддержки запуска тестов под отладчиком.10731074#### `countTestCases()`10751076Возвращает количество тестов, представленных этим тестовым объектом, включая все отдельные тесты и поднаборы.10771078#### `__iter__()`10791080Тесты, сгруппированные объектом [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite), всегда извлекаются через итерацию. Подклассы могут предоставлять тесты лениво, переопределяя [`__iter__()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.__iter__). Учтите, что этот метод может вызываться несколько раз для одного набора (например, при подсчете тестов или сравнении на равенство), поэтому тесты, возвращаемые при повторных итерациях до вызова [`TestSuite.run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.run), должны быть одинаковыми при каждом вызове. После [`TestSuite.run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.run) вызывающий код не должен полагаться на тесты, возвращаемые этим методом, если только он не использует подкласс, переопределяющий `TestSuite._removeTestAtIndex()` для сохранения ссылок на тесты.10811082Изменено в версии 3.2: В более ранних версиях [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) обращался к тестам напрямую, а не через итерацию, поэтому переопределения [`__iter__()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.__iter__) было недостаточно для предоставления тестов.10831084Изменено в версии 3.4: В более ранних версиях [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) сохранял ссылки на каждый [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) после вызова [`TestSuite.run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.run). Подклассы могут восстановить это поведение, переопределив `TestSuite._removeTestAtIndex()`.10851086В типичном использовании объекта [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) метод [`run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite.run) вызывается `TestRunner`, а не тестовым стендом конечного пользователя.10871088### Загрузка и запуск тестов10891090#### `class unittest.TestLoader`10911092Класс [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader) используется для создания тестовых наборов из классов и модулей. Обычно нет необходимости создавать экземпляр этого класса; модуль [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest) предоставляет экземпляр, который может использоваться совместно как [`unittest.defaultTestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.defaultTestLoader). Однако использование подкласса или экземпляра позволяет настраивать некоторые конфигурируемые свойства.10931094Объекты [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader) имеют следующие методы:10951096#### `loadTestsFromTestCase(testCaseClass)`10971098Возвращает набор всех тестовых случаев, содержащихся в классе `testCaseClass`, производном от [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase).10991100Экземпляр тестового случая создается для каждого метода, указанного [`getTestCaseNames()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.getTestCaseNames). По умолчанию это имена методов, начинающиеся с `test`. Если [`getTestCaseNames()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.getTestCaseNames) не возвращает ни одного метода, но реализован метод `runTest()`, то вместо этого создается один тестовый случай для этого метода.11011102#### `loadTestsFromModule(module)`11031104Возвращает набор всех тестовых случаев, содержащихся в данном модуле. Этот метод ищет в *module* классы, производные от [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), и создает экземпляр класса для каждого тестового метода, определенного в классе.11051106> **Примечание**1107>1108> Хотя использование иерархии классов, производных от [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), может быть удобным для совместного использования фикстур и вспомогательных функций, определение тестовых методов в базовых классах, которые не предназначены для прямого инстанцирования, плохо сочетается с этим методом. Однако это может быть полезно, когда фикстуры различаются и определяются в подклассах.11091110Если модуль предоставляет функцию `load_tests`, она будет вызвана для загрузки тестов. Это позволяет модулям настраивать загрузку тестов. Это [протокол load\_tests](https://python-all.ru/3.4/library/unittest.html#load-tests-protocol).11111112Изменено в версии 3.2: Добавлена поддержка `load_tests`.11131114#### `loadTestsFromName(name, module=None)`11151116Возвращает набор всех тестовых случаев по строковому спецификатору.11171118Спецификатор *name* – это «точечное имя», которое может разрешаться в модуль, класс тестового случая, тестовый метод внутри класса тестового случая, экземпляр [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) или вызываемый объект, возвращающий экземпляр [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) или [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite). Эти проверки применяются в указанном порядке; то есть метод в классе возможного тестового случая будет распознан как «тестовый метод внутри класса тестового случая», а не как «вызываемый объект».11191120Например, если у вас есть модуль `SampleTests`, содержащий класс `SampleTestCase`, производный от [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), с тремя тестовыми методами (`test_one()`, `test_two()` и `test_three()`), то спецификатор `'SampleTests.SampleTestCase'` приведет к тому, что этот метод вернет набор, который запустит все три тестовых метода. Использование спецификатора `'SampleTests.SampleTestCase.test_two'` приведет к возврату тестового набора, который запустит только тестовый метод `test_two()`. Спецификатор может ссылаться на модули и пакеты, которые еще не были импортированы; они будут импортированы как побочный эффект.11211122Метод опционально разрешает *name* относительно заданного *module*.11231124#### `loadTestsFromNames(names, module=None)`11251126Аналогично [`loadTestsFromName()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.loadTestsFromName), но принимает последовательность имён, а не одно имя. Возвращаемое значение – тестовый набор, содержащий все тесты, определённые для каждого имени.11271128#### `getTestCaseNames(testCaseClass)`11291130Возвращает отсортированную последовательность имён методов, найденных в *testCaseClass*; и он должен быть [подклассом `TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase).11311132#### `discover(start_dir, pattern='test*.py', top_level_dir=None)`11331134Находит все тестовые модули, рекурсивно обходя подкаталоги, начиная с указанного каталога, и возвращает объект TestSuite, содержащий их. Будут загружены только тестовые файлы, соответствующие *pattern*. (Используется сопоставление с образцом в стиле shell.) Будут загружены только имена модулей, которые можно импортировать (т.е. являются допустимыми идентификаторами Python).11351136Все тестовые модули должны быть импортируемыми из корневого каталога проекта. Если стартовый каталог не является корневым, то корневой каталог необходимо указать отдельно.11371138Если импорт модуля завершается неудачей, например из-за синтаксической ошибки, это будет зафиксировано как одна ошибка, и поиск продолжится. Если неудача импорта вызвана возбуждением [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest), это будет записано как пропуск, а не ошибка.11391140Если имя тестового пакета (каталог с `__init__.py`) соответствует шаблону, то в пакете будет проверено наличие функции `load_tests`. Если она существует, то она будет вызвана с аргументами *loader*, *tests*, *pattern*.11411142Если `load_tests` существует, то поиск *не* рекурсивно обходит пакет, `load_tests` отвечает за загрузку всех тестов в пакете.11431144Шаблон намеренно не хранится как атрибут загрузчика, чтобы пакеты могли продолжать поиск самостоятельно. *top\_level\_dir* хранится, чтобы `load_tests` не нужно было передавать этот аргумент в `loader.discover()`.11451146*start\_dir* может быть как точечным именем модуля, так и каталогом.11471148Новое в версии 3.2.11491150Изменено в версии 3.4: Модули, возбуждающие [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest) при импорте, записываются как пропуски, а не ошибки. Поиск работает для [*пакетов пространств имён*](https://python-all.ru/3.4/glossary.html#term-namespace-package). Пути сортируются перед импортом, чтобы порядок выполнения был одинаковым, даже если порядок в файловой системе не зависит от имени файла.11511152Следующие атрибуты [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader) можно настроить либо через создание подкласса, либо присваиванием экземпляру:11531154#### `testMethodPrefix`11551156Строка, задающая префикс имён методов, которые будут интерпретироваться как тестовые методы. Значение по умолчанию – `'test'`.11571158Это влияет на [`getTestCaseNames()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.getTestCaseNames) и все методы `loadTestsFrom*()`.11591160#### `sortTestMethodsUsing`11611162Функция, используемая для сравнения имён методов при сортировке в [`getTestCaseNames()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.getTestCaseNames) и во всех методах `loadTestsFrom*()`.11631164#### `suiteClass`11651166Вызываемый объект, который создаёт тестовый набор из списка тестов. Никакие методы результирующего объекта не требуются. Значение по умолчанию – класс [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite).11671168Это влияет на все методы `loadTestsFrom*()`.11691170#### `class unittest.TestResult`11711172Этот класс используется для сбора информации о том, какие тесты прошли успешно, а какие завершились неудачей.11731174Объект [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) хранит результаты набора тестов. Классы [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) обеспечивают корректную запись результатов; авторам тестов не нужно заботиться о записи результатов тестов.11751176Тестовые фреймворки, построенные на основе [`unittest`](https://python-all.ru/3.4/library/unittest.html#module-unittest), могут нуждаться в доступе к объекту [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult), создаваемому при выполнении набора тестов для целей отчётности; экземпляр [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) возвращается методом `TestRunner.run()` для этой цели.11771178Экземпляры [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) имеют следующие атрибуты, которые будут интересны при просмотре результатов выполнения набора тестов:11791180#### `errors`11811182Список, содержащий кортежи из двух элементов: экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и строки с форматированными трассировками. Каждый кортеж представляет тест, вызвавший неожиданное исключение.11831184#### `failures`11851186Список, содержащий кортежи из двух элементов: экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и строки с форматированными трассировками. Каждый кортеж представляет тест, в котором ошибка была явно зафиксирована с помощью методов `TestCase.assert*()`.11871188#### `skipped`11891190Список, содержащий кортежи из двух элементов: экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и строки с причиной пропуска теста.11911192Новое в версии 3.1.11931194#### `expectedFailures`11951196Список, содержащий кортежи из двух элементов: экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) и строки с форматированными трассировками. Каждый кортеж представляет ожидаемую ошибку тестового случая.11971198#### `unexpectedSuccesses`11991200Список, содержащий экземпляры [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), которые были отмечены как ожидаемые ошибки, но прошли успешно.12011202#### `shouldStop`12031204Устанавливается в `True`, когда выполнение тестов должно быть остановлено вызовом [`stop()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.stop).12051206#### `testsRun`12071208Общее количество запущенных на данный момент тестов.12091210#### `buffer`12111212Если установлено в true, `sys.stdout` и `sys.stderr` будут буферизироваться между вызовами [`startTest()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.startTest) и [`stopTest()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.stopTest). Собранный вывод будет выводиться в настоящие `sys.stdout` и `sys.stderr` только если тест завершается неудачей или ошибкой. Любой вывод также присоединяется к сообщению об ошибке или сбое.12131214Новое в версии 3.2.12151216#### `failfast`12171218Если установлено в true, [`stop()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.stop) будет вызван при первой неудаче или ошибке, останавливая выполнение тестов.12191220Новое в версии 3.2.12211222#### `wasSuccessful()`12231224Возвращает `True`, если все выполненные на данный момент тесты прошли, иначе возвращает `False`.12251226Изменено в версии 3.4: Возвращает `False`, если были какие-либо [`неожиданные успехи`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.unexpectedSuccesses) от тестов, помеченных декоратором [`expectedFailure()`](https://python-all.ru/3.4/library/unittest.html#unittest.expectedFailure).12271228#### `stop()`12291230Этот метод может быть вызван, чтобы сигнализировать, что выполняемый набор тестов должен быть прерван установкой атрибута [`shouldStop`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.shouldStop) в `True`. Объекты `TestRunner` должны учитывать этот флаг и возвращаться без выполнения дополнительных тестов.12311232Например, эта возможность используется классом [`TextTestRunner`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestRunner) для остановки тестового фреймворка, когда пользователь подает сигнал прерывания с клавиатуры. Интерактивные инструменты, предоставляющие реализации `TestRunner`, могут использовать это аналогичным образом.12331234Следующие методы класса [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) используются для поддержки внутренних структур данных и могут быть расширены в подклассах для поддержки дополнительных требований к отчетности. Это особенно полезно при создании инструментов, поддерживающих интерактивную отчетность во время выполнения тестов.12351236#### `startTest(test)`12371238Вызывается перед запуском тестового сценария *test*.12391240#### `stopTest(test)`12411242Вызывается после выполнения тестового сценария *test*, независимо от результата.12431244#### `startTestRun()`12451246Вызывается один раз перед выполнением любых тестов.12471248Новое в версии 3.1.12491250#### `stopTestRun()`12511252Вызывается один раз после выполнения всех тестов.12531254Новое в версии 3.1.12551256#### `addError(test, err)`12571258Вызывается, когда тестовый пример *test* вызывает неожиданное исключение. *err* – это кортеж в формате, возвращаемом [`sys.exc_info()`](https://python-all.ru/3.4/library/sys.html#sys.exc_info): `(type, value, traceback)`.12591260Реализация по умолчанию добавляет кортеж `(test, formatted_err)` в атрибут [`errors`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.errors) экземпляра, где *formatted\_err* – это форматированная трассировка, полученная из *err*.12611262#### `addFailure(test, err)`12631264Вызывается, когда тестовый пример *test* сигнализирует о неудаче. *err* – это кортеж в формате, возвращаемом [`sys.exc_info()`](https://python-all.ru/3.4/library/sys.html#sys.exc_info): `(type, value, traceback)`.12651266Реализация по умолчанию добавляет кортеж `(test, formatted_err)` в атрибут [`failures`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.failures) экземпляра, где *formatted\_err* – это форматированная трассировка, полученная из *err*.12671268#### `addSuccess(test)`12691270Вызывается, когда тестовый сценарий *test* завершается успешно.12711272Реализация по умолчанию ничего не делает.12731274#### `addSkip(test, reason)`12751276Вызывается, когда тестовый сценарий *test* пропускается. *reason* – причина, которую тест указал для пропуска.12771278Реализация по умолчанию добавляет кортеж `(test, reason)` в атрибут [`skipped`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.skipped) экземпляра.12791280#### `addExpectedFailure(test, err)`12811282Вызывается, когда тестовый пример *test* завершается неудачей, но был помечен декоратором [`expectedFailure()`](https://python-all.ru/3.4/library/unittest.html#unittest.expectedFailure).12831284Реализация по умолчанию добавляет кортеж `(test, formatted_err)` в атрибут [`expectedFailures`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.expectedFailures) экземпляра, где *formatted\_err* – это форматированная трассировка, полученная из *err*.12851286#### `addUnexpectedSuccess(test)`12871288Вызывается, когда тестовый пример *test* был помечен декоратором [`expectedFailure()`](https://python-all.ru/3.4/library/unittest.html#unittest.expectedFailure), но завершился успешно.12891290Реализация по умолчанию добавляет тест в атрибут [`unexpectedSuccesses`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.unexpectedSuccesses) экземпляра.12911292#### `addSubTest(test, subtest, outcome)`12931294Вызывается, когда завершается подтест. *test* – это тестовый пример, соответствующий тестовому методу. *subtest* – это настраиваемый экземпляр [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), описывающий подтест.12951296Если *outcome* равен [`None`](https://python-all.ru/3.4/library/constants.html#None), подтест выполнен успешно. В противном случае он завершился с исключением, где *outcome* – это кортеж вида, возвращаемого функцией [`sys.exc_info()`](https://python-all.ru/3.4/library/sys.html#sys.exc_info): `(type, value, traceback)`.12971298Реализация по умолчанию ничего не делает, если результат – успех, и записывает сбои подтестов как обычные сбои.12991300Новое в версии 3.4.13011302#### `class unittest.TextTestResult(stream, descriptions, verbosity)`13031304Конкретная реализация [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult), используемая [`TextTestRunner`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestRunner).13051306Новое в версии 3.2: Ранее этот класс назывался `_TextTestResult`. Старое имя всё ещё существует как псевдоним, но является устаревшим.13071308#### `unittest.defaultTestLoader`13091310Экземпляр класса [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader), предназначенный для совместного использования. Если настройка [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader) не требуется, можно использовать этот экземпляр вместо многократного создания новых.13111312#### `class unittest.TextTestRunner(stream=None, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None)`13131314Базовая реализация средства запуска тестов, которая выводит результаты в поток данных. Если *stream* равен `None` (по умолчанию), в качестве выходного потока данных используется [`sys.stderr`](https://python-all.ru/3.4/library/sys.html#sys.stderr). Этот класс имеет несколько настраиваемых параметров, но в целом очень прост. Графические приложения, которые запускают наборы тестов, должны предоставлять альтернативные реализации.13151316По умолчанию этот запускатор показывает [`DeprecationWarning`](https://python-all.ru/3.4/library/exceptions.html#DeprecationWarning), [`PendingDeprecationWarning`](https://python-all.ru/3.4/library/exceptions.html#PendingDeprecationWarning), [`ResourceWarning`](https://python-all.ru/3.4/library/exceptions.html#ResourceWarning) и [`ImportWarning`](https://python-all.ru/3.4/library/exceptions.html#ImportWarning), даже если они [*игнорируются по умолчанию*](https://python-all.ru/3.4/library/warnings.html#warning-ignored). Предупреждения об устаревании, вызванные [*устаревшими методами unittest*](https://python-all.ru/3.4/library/unittest.html#deprecated-aliases), также обрабатываются особым образом: когда фильтры предупреждений установлены в `'default'` или `'always'`, они будут появляться только один раз на модуль, чтобы избежать слишком большого количества предупреждений. Это поведение можно переопределить с помощью опций *-Wd* или *-Wa*, оставив *warnings* равным `None`.13171318Изменено в версии 3.2: Добавлен аргумент `warnings`.13191320Изменено в версии 3.2: Поток по умолчанию устанавливается в [`sys.stderr`](https://python-all.ru/3.4/library/sys.html#sys.stderr) во время создания экземпляра, а не во время импорта.13211322#### `_makeResult()`13231324Этот метод возвращает экземпляр `TestResult`, используемый [`run()`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestRunner.run). Он не предназначен для прямого вызова, но может быть переопределён в подклассах для предоставления собственного `TestResult`.13251326`_makeResult()` создаёт экземпляр класса или вызываемого объекта, переданного в конструктор `TextTestRunner` в качестве аргумента `resultclass`. По умолчанию используется [`TextTestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestResult), если `resultclass` не предоставлен. Класс результата создаётся со следующими аргументами:13271328```python1329stream, descriptions, verbosity1330```13311332#### `run(test)`13331334Этот метод является основным публичным интерфейсом *TextTestRunner*. Он принимает экземпляр [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite) или [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase). Вызовом [`_makeResult()`](https://python-all.ru/3.4/library/unittest.html#unittest.TextTestRunner._makeResult) создаётся [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult), тесты выполняются, а результаты выводятся в stdout.13351336#### `unittest.main(module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=unittest.defaultTestLoader, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None, warnings=None)`13371338Программа командной строки, которая загружает набор тестов из *module* и запускает их; это в первую очередь для удобного выполнения тестовых модулей. Простейший способ использования этой функции – добавить следующую строку в конец тестового скрипта:13391340```python1341if __name__ == '__main__':1342    unittest.main()1343```13441345Можно запускать тесты с более подробной информацией, передав аргумент verbosity:13461347```python1348if __name__ == '__main__':1349    unittest.main(verbosity=2)1350```13511352Аргумент *defaultTest* – это либо имя одного теста, либо итерируемый объект с именами тестов, которые нужно запустить, если имена не указаны через *argv*. Если он не указан или равен `None`, и имена тестов не переданы через *argv*, запускаются все тесты, найденные в *module*.13531354Аргумент *argv* может быть списком параметров, переданных программе, где первый элемент – имя программы. Если он не указан или равен `None`, используются значения [`sys.argv`](https://python-all.ru/3.4/library/sys.html#sys.argv).13551356Аргумент *testRunner* может быть либо классом средства запуска тестов, либо уже созданным экземпляром такого класса. По умолчанию `main` вызывает [`sys.exit()`](https://python-all.ru/3.4/library/sys.html#sys.exit) с кодом возврата, указывающим на успех или неудачу выполнения тестов.13571358Аргумент *testLoader* должен быть экземпляром [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader), по умолчанию используется [`defaultTestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.defaultTestLoader).13591360`main` поддерживает использование из интерактивного интерпретатора путём передачи аргумента `exit=False`. При этом результат выводится на стандартный вывод без вызова [`sys.exit()`](https://python-all.ru/3.4/library/sys.html#sys.exit):13611362```python1363>>> from unittest import main1364>>> main(module='test_module', exit=False)1365```13661367Параметры *failfast*, *catchbreak* и *buffer* имеют тот же эффект, что и одноимённые [параметры командной строки](https://python-all.ru/3.4/library/unittest.html#command-line-options).13681369Аргумент *warning* задаёт [*фильтр предупреждений*](https://python-all.ru/3.4/library/warnings.html#warning-filter), который следует использовать во время выполнения тестов. Если он не указан, он останется равным `None`, если опция *-W* передана **python**, в противном случае он будет установлен в `'default'`.13701371Вызов `main` на самом деле возвращает экземпляр класса `TestProgram`. Результат выполнения тестов сохраняется в атрибуте `result`.13721373Изменено в версии 3.1: Добавлен параметр *exit*.13741375Изменено в версии 3.2: Добавлены параметры *verbosity*, *failfast*, *catchbreak*, *buffer* и *warnings*.13761377Изменено в версии 3.4: Параметр *defaultTest* был изменён: теперь он также принимает итерируемый объект с именами тестов.13781379#### 26.3.8.3.1. load\_tests протокол13801381Новое в версии 3.2.13821383Модули или пакеты могут настраивать загрузку тестов из себя во время обычного запуска тестов или обнаружения тестов, реализуя функцию с именем `load_tests`.13841385Если тестовый модуль определяет `load_tests`, он будет вызван [`TestLoader.loadTestsFromModule()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.loadTestsFromModule) со следующими аргументами:13861387```python1388load_tests(loader, standard_tests, None)1389```13901391Она должна возвращать [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite).13921393*loader* – это экземпляр [`TestLoader`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader), который выполняет загрузку. *standard\_tests* – это тесты, которые загружаются по умолчанию из модуля. Обычно тестовые модули хотят только добавить или удалить тесты из стандартного набора. Третий аргумент используется при загрузке пакетов в ходе обнаружения тестов.13941395Типичная функция `load_tests`, которая загружает тесты из определённого набора классов [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase), может выглядеть так:13961397```python1398test_cases = (TestCase1, TestCase2, TestCase3)13991400def load_tests(loader, tests, pattern):1401    suite = TestSuite()1402    for test_class in test_cases:1403        tests = loader.loadTestsFromTestCase(test_class)1404        suite.addTests(tests)1405    return suite1406```14071408Если запущено обнаружение (из командной строки или вызовом [`TestLoader.discover()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestLoader.discover)) с шаблоном, соответствующим имени пакета, то в пакете `__init__.py` будет проверено наличие `load_tests`.14091410> **Примечание**1411>1412> Шаблон по умолчанию – `'test*.py'`. Он соответствует всем Python-файлам, начинающимся с `'test'`, но *не* соответствует тестовым каталогам.1413>1414> Шаблон вида `'test*'` будет соответствовать как тестовым пакетам, так и модулям.14151416Если в пакете `__init__.py` определена `load_tests`, то она будет вызвана, и обнаружение в пакете не продолжится. `load_tests` вызывается со следующими аргументами:14171418```python1419load_tests(loader, standard_tests, pattern)1420```14211422Она должна вернуть [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite), представляющий все тесты из пакета. (`standard_tests` будет содержать только тесты, собранные из `__init__.py`.)14231424Поскольку шаблон передаётся в `load_tests`, пакет может продолжить (и, возможно, изменить) обнаружение тестов. Функция `load_tests`, которая «ничего не делает» для тестового пакета, будет выглядеть так:14251426```python1427def load_tests(loader, standard_tests, pattern):1428    # корневой каталог, кэшированный на экземпляре загрузчика1429    this_dir = os.path.dirname(__file__)1430    package_tests = loader.discover(start_dir=this_dir, pattern=pattern)1431    standard_tests.addTests(package_tests)1432    return standard_tests1433```14341435## 26.3.9. Фикстуры классов и модулей14361437Фикстуры уровня класса и модуля реализованы в [`TestSuite`](https://python-all.ru/3.4/library/unittest.html#unittest.TestSuite). Когда тестовый набор встречает тест из нового класса, вызывается `tearDownClass()` из предыдущего класса (если он есть), а затем `setUpClass()` из нового класса.14381439Аналогично, если тест из другого модуля, отличного от предыдущего, то выполняется `tearDownModule` из предыдущего модуля, а затем `setUpModule` из нового модуля.14401441После выполнения всех тестов запускаются финальные `tearDownClass` и `tearDownModule`.14421443Обратите внимание, что общие фикстуры плохо совместимы с такими возможностями, как параллельное выполнение тестов, и нарушают изоляцию тестов. Их следует использовать с осторожностью.14441445Порядок тестов по умолчанию, создаваемый загрузчиками тестов unittest, группирует все тесты из одних и тех же модулей и классов вместе. Это приводит к тому, что `setUpClass` / `setUpModule` (и т.д.) вызываются ровно один раз для каждого класса и модуля. Если перемешать порядок так, чтобы тесты из разных модулей и классов оказались рядом, эти общие функции фикстур могут быть вызваны несколько раз в одном запуске тестов.14461447Общие фикстуры не предназначены для работы с наборами, имеющими нестандартный порядок. `BaseTestSuite` по-прежнему существует для фреймворков, которые не хотят поддерживать общие фикстуры.14481449Если в одной из общих функций фикстур возникает исключение, тест отмечается как ошибочный. Поскольку соответствующего экземпляра теста нет, создаётся объект `_ErrorHolder` (с тем же интерфейсом, что и у [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase)) для представления ошибки. Если используется стандартный исполнитель тестов unittest, эта деталь не имеет значения, но для авторов фреймворков она может быть актуальной.14501451### 26.3.9.1. setUpClass и tearDownClass14521453Они должны быть реализованы как методы класса:14541455```python1456import unittest14571458class Test(unittest.TestCase):1459    @classmethod1460    def setUpClass(cls):1461        cls._connection = createExpensiveConnectionObject()14621463    @classmethod1464    def tearDownClass(cls):1465        cls._connection.destroy()1466```14671468Если нужно, чтобы `setUpClass` и `tearDownClass` в базовых классах вызывались, то их необходимо вызывать явно. Реализации в [`TestCase`](https://python-all.ru/3.4/library/unittest.html#unittest.TestCase) пусты.14691470Если во время `setUpClass` возникает исключение, тесты в классе не выполняются, и `tearDownClass` не вызывается. Пропущенные классы не будут иметь выполненных `setUpClass` или `tearDownClass`. Если исключение – это [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest), то класс будет отмечен как пропущенный, а не как ошибочный.14711472### 26.3.9.2. setUpModule и tearDownModule14731474Их следует реализовывать как функции:14751476```python1477def setUpModule():1478    createConnection()14791480def tearDownModule():1481    closeConnection()1482```14831484Если в `setUpModule` возникает исключение, ни один из тестов в модуле не будет выполнен, и `tearDownModule` не будет вызван. Если исключение – это [`SkipTest`](https://python-all.ru/3.4/library/unittest.html#unittest.SkipTest), то модуль будет отмечен как пропущенный, а не как ошибочный.14851486## 26.3.10. Обработка сигналов14871488Новое в версии 3.2.14891490Параметр командной строки [*-c/--catch*](https://python-all.ru/3.4/library/unittest.html#cmdoption-unittest-c) для unittest, а также параметр `catchbreak` для [`unittest.main()`](https://python-all.ru/3.4/library/unittest.html#unittest.main), обеспечивают более удобную обработку Ctrl+C во время запуска тестов. При включённом поведении перехвата Ctrl+C позволяет завершиться текущему выполняющемуся тесту, а затем выполнение тестов завершается и выводятся все результаты на данный момент. Повторное нажатие Ctrl+C вызовет [`KeyboardInterrupt`](https://python-all.ru/3.4/library/exceptions.html#KeyboardInterrupt) обычным образом.14911492Обработчик сигнала Ctrl+C пытается оставаться совместимым с кодом или тестами, которые устанавливают свой собственный обработчик `signal.SIGINT`. Если вызывается обработчик `unittest`, но он *не является* установленным обработчиком `signal.SIGINT`, т.е. он был заменён тестируемой системой и делегирован ей, то вызывается обработчик по умолчанию. Обычно это ожидаемое поведение для кода, который заменяет установленный обработчик и делегирует ему. Для отдельных тестов, которым требуется отключить обработку Ctrl+C в `unittest`, можно использовать декоратор [`removeHandler()`](https://python-all.ru/3.4/library/unittest.html#unittest.removeHandler).14931494Существует несколько вспомогательных функций для разработчиков фреймворков, позволяющих включить обработку control-c в тестовых фреймворках.14951496#### `unittest.installHandler()`14971498Устанавливает обработчик Ctrl+C. При получении `signal.SIGINT` (обычно в ответ на нажатие пользователем Ctrl+C) у всех зарегистрированных результатов вызывается [`stop()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.stop).14991500#### `unittest.registerResult(result)`15011502Регистрирует объект [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) для обработки Ctrl+C. Регистрация результата сохраняет слабую ссылку на него, поэтому это не мешает сборщику мусора удалить результат.15031504Регистрация объекта [`TestResult`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult) не имеет побочных эффектов, если обработка Ctrl+C не включена, поэтому тестовые фреймворки могут безоговорочно регистрировать все создаваемые ими результаты независимо от того, включена ли обработка.15051506#### `unittest.removeResult(result)`15071508Удаляет зарегистрированный результат. После удаления результата [`stop()`](https://python-all.ru/3.4/library/unittest.html#unittest.TestResult.stop) больше не будет вызываться для этого объекта результата в ответ на Ctrl+C.15091510#### `unittest.removeHandler(function=None)`15111512При вызове без аргументов эта функция удаляет обработчик сочетания клавиш Control-C, если он был установлен. Эту функцию также можно использовать как декоратор теста, чтобы временно удалить обработчик на время выполнения теста:15131514```python1515@unittest.removeHandler1516def test_signal_handling(self):1517    ...1518```1519