Как запустить unittest python

• Модуль csv - чтение и запись CSV файлов
• Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
• Онлайн-обучение Python: сравнение популярных программ

• Книги о Python
• GUI (графический интерфейс пользователя)
• Курсы Python
• Модули
• Новости мира Python
• NumPy
• Обработка данных
• Основы программирования
• Примеры программ
• Типы данных в Python
• Видео
• Python для Web
• Работа для Python-программистов

• Сделай свой вклад в развитие сайта!
• Самоучитель Python
• Карта сайта
• Отзывы на книги по Python
• Реклама на сайте

Юнит-тесты на Python: Быстрый старт

Юнит-тестирование кода является неотъемлемой частью жизненного цикла разработки программного обеспечения. Юнит-тесты также формируют основу для проведения регрессионного тестирования, то есть они гарантируют, что система будет вести себя согласно сценарию, когда добавятся новые функциональные возможности или изменятся существующие.

В этой статье я продемонстрирую основную идею юнит-тестирования на одном классе. На практике вам придется писать множество тестовых случаев, добавлять их в тестовый набор и запускать все вместе. Управление тест-кейсами мы рассмотрим в следующей статье.

Сегодня мы сосредоточимся на тестировании бэкенда. То есть разработчик реализовал некоторый проект согласно спецификациям (например, Calculator.py), а ваша задача состоит в том, чтобы убедиться, что разработанный код действительно им соответствует (например, с помощью TestCalculator.py ).

Предположим, что вы написали класс Calculator для выполнения основных вычислительных функций: сложения, вычитания, умножения и деления.

Код для этого здесь ( Calculator.py ):

#A simple calculator class Calculator: #empty constructor def __init__(self): pass #add method - given two numbers, return the addition def add(self, x1, x2): return x1 + x2 #multiply method - given two numbers, return the #multiplication of the two def multiply(self, x1, x2): return x1 * x2 #subtract method - given two numbers, return the value #of first value minus the second def subtract(self, x1, x2): return x1 - x2 #divide method - given two numbers, return the value #of first value divided by the second def divide(self, x1, x2): if x2 != 0: return x1/x2

Теперь я хочу запустить юнит-тест, чтобы понять, что функциональность в приведенном выше классе работает, как запланировано.

Обычно Python поставляется уже с пакетом unittest . Если в вашей системе его нет, используйте pip для его установки.

Юнит-тест имеет следующую структуру:

setUp() и tearDown() – это стандартные методы, которые поставляются с фреймворком unittest (они определены в классе unittest.TestCase). В зависимости от вашего тестового случая вы можете переопределять или не переопределять два этих метода по умолчанию.

Пришло время посмотреть на код тест-кейса. Вот файл TestCalculator.py .

import unittest from Calculator import Calculator #Test cases to test Calulator methods #You always create a child class derived from unittest.TestCase class TestCalculator(unittest.TestCase): #setUp method is overridden from the parent class TestCase def setUp(self): self.calculator = Calculator() #Each test method starts with the keyword test_ def test_add(self): self.assertEqual(self.calculator.add(4,7), 11) def test_subtract(self): self.assertEqual(self.calculator.subtract(10,5), 5) def test_multiply(self): self.assertEqual(self.calculator.multiply(3,7), 21) def test_divide(self): self.assertEqual(self.calculator.divide(10,2), 5) # Executing the tests in the above test case class if __name__ == "__main__": unittest.main()

Хотя это и не обязательно, но как правило я называю тестовый класс с префиксом Test (в нашем случае TestCalculator). Ключевым требованием в этом классе является наличие надкласса unittest.TestCase .

Всякий раз, когда выполняется этот тест-кейс, сначала выполняется метод setUp(). В нашем случае мы просто создаем объект класса Calculator и сохраняем его как атрибут класса. В родительском классе есть несколько других методов по умолчанию, которые мы рассмотрим позже.

На данный момент все, что вы будете делать, это писать методы test_xxx для тестирования каждого метода в классе Calculator. Обратите внимание, что все тестовые методы начинаются с префикса test_ . Это говорит Python с помощью фреймворка unittest, что это методы тестирования.

В каждом из методов тестирования я использовал встроенный метод assertEqual , чтобы проверить, возвращают ли методы калькулятора ожидаемое значение. Если возвращаемое значение равно ожидаемому значению, то тест проходит успешно, в противном случае он завершается неудачей.

Есть множество встроенных методов assert , о которых мы будем говорить позже.

Последняя строка в приведенном выше коде просто запускает тестовый случай TestCalculator . Он выполняет каждый тестовый метод, определенный внутри класса, и выдает результат.

python TestCalculator.py -v

Вы увидите вывод, сходный со следующим:

test_add (__main__.TestCalculator) . ok test_divide (__main__.TestCalculator) . ok test_multiply (__main__.TestCalculator) . ok test_subtract (__main__.TestCalculator) . ok -------------------------------------------------------------------- Ran 4 tests in 0.000s OK

Что делать, если что-то не работает, как ожидалось? Давайте изменим ожидаемое значение test_divide с 5 на 6 (5 – правильное значение, сейчас мы посмотрим, что случится при сбое. Это не ошибка в исходном коде, а ошибка в тестовом наборе, у вас тоже могут быть ошибки в тестовых наборах, поэтому всегда проверяйте тестовые сценарии на наличие ошибок!)

import unittest from Calculator import Calculator #Test cases to test Calulator methods #You always create a child class derived from unittest.TestCase class class TestCalculator(unittest.TestCase): #setUp method overridden from the parent class TestCase def setUp(self): self.calculator = Calculator() . def test_divide(self): self.assertEqual(self.calculator.divide(10,2), 6) # Executing the tests in the above test case class if __name__ == "__main__": unittest.main()

При запуске этого тест-кейса, вы получите следующий результат:

test_add (__main__.TestCalculator) . ok test_divide (__main__.TestCalculator) . FAIL test_multiply (__main__.TestCalculator) . ok test_subtract (__main__.TestCalculator) . ok ==================================================================== FAIL: test_divide (__main__.TestCalculator) -------------------------------------------------------------------- Traceback (most recent call last): File "TestCalculator.py", line 23, in test_divide self.assertEqual(self.calculator.divide(10,2), 6) AssertionError: 5.0 != 6 -------------------------------------------------------------------- Ran 4 tests in 0.001s FAILED (failures=1)

Здесь написано, что 3 из 4 тестов прошли успешно, а один не удался. В реальном сценарии, предполагается, что ваш тестовый случай является верным, то есть таким образом он помогает определять неправильно реализованную функцию.

• Блог компании OTUS
• Python
• Тестирование веб-сервисов

Тестирование в Python [unittest]. Часть 2. TestCase

Продолжаем изучать unittest – framework для тестирования в Python. В этой статье сосредоточимся на общем обзоре основных структурных элементов unittest (test case, test suite, test runner), рассмотрим способы запуска тестов и подробно остановимся на классе TestCase.

1. Основные структурные элементы unittest.
2. Запуск тестов из командной строки и с использованием графического приложения.
3. Работа с TestCase.

Основные структурные элементы unittest

unittest – это framework для тестирования в Python, который позволяет разрабатывать автономные тесты, собирать тесты в коллекции, обеспечивает независимость тестов от framework’а отчетов и т.д. Основными структурными элемента каркаса unittest являются:

Test fixture

Test fixture – обеспечивает подготовку окружения для выполнения тестов, а также организацию мероприятий по их корректному завершению (например очистка ресурсов). Подготовка окружения может включать в себя создание баз данных, запуск необходим серверов и т.п.

Test case

Test case – это элементарная единица тестирования, в рамках которой проверяется работа компонента тестируемой программы (метод, класс, поведение и т.п.). Для реализации этой сущности используется класс TestCase.

Test suite

Test suite – это коллекция тестов, которая может в себя включать как отдельные test case’ы так и целые коллекции (т.е. можно создавать коллекции коллекций). Коллекции используются с целью объединения тестов для совместного запуска.

Test runner

Test runner – это компонент, которые оркестрирует (координирует взаимодействие) запуск тестов и предоставляет пользователю результат их выполнения. Test runner может иметь графический интерфейс, текстовый интерфейс или возвращать какое-то заранее заданное значение, которое будет описывать результат прохождения тестов.

Вся работа по написанию тестов заключается в том, что мы разрабатываем отдельные тесты в рамках test case’ов, собираем их в модули и запускаем, если нужно объединить несколько test case’ов, для их совместного запуска, они помещаются в test suite’ы, которые помимо test case’ов могут содержать другие test suite’ы.

Запуск тестов из командной строки и с использованием графического приложения

Запуск тестов можно сделать как из командной строки, так и с помощью графического интерфейса пользователя (GUI), рассмотрим каждый из этих способов более подробно. В качестве примера приложения, будет выступать utest_calc.py из предыдущей статьи.

Интерфейс командной строки (CLI)

CLI позволяет запускать тесты из целого модуля, класса или даже обращаться к конкретному тесту.

Запуск всех тестов в модуле utest_calc.py.

> python -m unittest test_calc.py

Запуск тестов из класса CalcTest.

> python -m unittest utest_calc.CalcTest

Запуск теста test_sub().

> python -m unittest utest_calc.CalcTest.test_sub

Как уже было сказано в первой части данного цикла, для вывода подробной информации необходимо добавить ключ -v.

> python -m unittest -v utest_calc.py

Если осуществить запуск без указания модуля с тестами, будет запущен Test Discovery.

> python -m unittest

Более подробно о Test Discovery будет рассказано в одной из следующих частей. С правку по ключам запуска можно получить из документации.

Графический интерфейс пользователя (GUI)

Для запуска и анализа результатов работы тестов можно использовать GUI. Списко инструментов доступен здесь , но он далеко не полный. Для пример рассмотрим работу с Cricket . Для установки Cricket можно воспользоваться менеджером pip:

> pip install cricket

После этого на ваш компьютер будет установлен cricket-unittest.

Для запуска тестов в данном приложении, перейдите в каталог с вашим тестирующим кодом и в командной строке запустите cricket-unittest, для этого просто наберите это название и нажмите Enter.

> cricket-unittest

Приложение, при запуске, автоматически загрузит тесты.

Для запуска тестов нажмите “Run all”. Как видно, все тесты завершились удачно – они окрасились в зеленый цвет.

Работа с TestCase

Как уже было сказано – основным строительным элементом при написании тестов с использованием unittest является TestCase. Он представляет собой класс, который должен являться базовым для всех остальных классов, методы которых будут тестировать те или иные автономные единицы исходной программы.

Приведем еще раз класс CalcTest из предыдущего урока:

import unittest import calc class CalcTests(unittest.TestCase): def test_add(self): self.assertEqual(calc.add(1, 2), 3) def test_sub(self): self.assertEqual(calc.sub(4, 2), 2) def test_mul(self): self.assertEqual(calc.mul(2, 5), 10) def test_div(self): self.assertEqual(calc.div(8, 4), 2) if __name__ == '__main__': unittest.main()

Для того, чтобы была возможность использовать компоненты unittest (в том числе и TestCase), в самом начале программы нужно импортировать модуль unittest стандартным образом.

При выборе имени класса наследника от TestCase можете руководствоваться следующим правилом: [ИмяТестируемойСущности]Tests. [ИмяТестируемойСущности] – это некоторая логическая единица, тесты для которой нужно написать. В нашем случае – это калькулятор, поэтому мы выбрали имя CalcTests. Если бы у нашего калькулятора был большой набор поддерживаемых функций, то тестирование простых функций (сложение, вычитание, умножение и деление) можно было бы вынести в отдельный класс и назвать его например так: CalcSimpleActionsTests. При написании программ на Python старайтесь придерживаться PEP 8 — Style Guide for Python Code – это рекомендации по стилевому оформлению кода.

Для того, чтобы метод класса выполнялся как тест, необходимо, чтобы он начинался со слова test. Несмотря на то, что методы framework’а unittest написаны не в соответствии с PEP 8 (ввиду того, что идейно он наследник xUnit), мы все же рекомендуем следовать правилам стиля для Python везде, где это возможно. Поэтому имена тестов будем начинать с префикса test_. Далее, под словом тест будем понимать метод класса-наследника от TestCase, который начинается с префикса test_.

Все методы класса TestCase можно разделить на три группы:

• методы, используемые при запуске тестов;
• методы, используемые при непосредственном написании тестов (проверка условий, сообщение об ошибках);
• методы, позволяющие собирать информацию о самом тесте.

Рассмотрим методы этих групп более подробно. Остановимся только на тех методах, которые могут быть полезны в первую очередь, при разработке тестов. За более подробной информацией отправляем на сайт с официальной документацией.

Методы, используемые при запуске тестов.

К этим методам относятся:

Метод вызывается перед запуском теста. Как правило, используется для подготовки окружения для теста.

tearDown()

Метод вызывается после завершения работы теста. Используется для “приборки” за тестом.

Заметим, что методы setUp() и tearDown() вызываются для всех тестов в рамках класса, в котором они переопределены. По умолчанию, эти методы ничего не делают. Если их добавить в utest_calc.py, то перед [после] тестов test_add(), test_sub(), test_mul(), test_div() будут выполнены setUp() [tearDown()].

setUpClass()

Метод действует на уровне класса, т.е. выполняется перед запуском тестов класса. При этом синтаксис требует наличие декоратора @classmethod.

@classmethod def setUpClass(cls): .

tearDownClass()

Запускается после выполнения всех методов класса, требует наличия декоратора @classmethod.

@classmethod def tearDownClass(cls): .

skipTest(reason)

Данный метод может быть использован для пропуска теста, если это необходимо.

Методы, используемые при непосредственном написании тестов (проверка условий, сообщение об ошибках).

TestCase класс предоставляет набор assert-методов для проверки и генерации ошибок:

Assert’ы для контроля выбрасываемых исключений и warning’ов:

Assert’ы для проверки различных ситуаций:

Типо-зависимые assert’ы, которые используются при вызове assertEqual() . Приводятся на тот случай, если необходимо использовать конкретный метод.

Дополнительно хотелось бы отметить метод fail().

fail(msg=None)

Этот метод сигнализирует о том, что произошла ошибка в тесте.

Методы, позволяющие собирать информацию о самом тесте.

countTestCases()

Возвращает количество тестов в объекте класса-наследника от TestCase.

Возвращает строковый идентификатор теста. Как правило это полное имя метода, включающее имя модуля и имя класса.

shortDescription()

Возвращает описание теста, которое представляет собой первую строку docstring’а метода, если его нет, то возвращает None.

Расширим код нашего тестового проекта utest_calc.py, так чтобы показать некоторые из возможностей, которые предоставляет класс TestCase.

import unittest import calc class CalcTest(unittest.TestCase): """Calc tests""" @classmethod def setUpClass(cls): """Set up for class""" print("setUpClass") print("========= color: #5a525f; font-style: italic;">@classmethod def tearDownClass(cls): """Tear down for class""" print("========= color: #794938;">print("tearDownClass") def setUp(self): """Set up for test""" print("Set up for [" + self.shortDescription() + "]") def tearDown(self): """Tear down for test""" print("Tear down for [" + self.shortDescription() + "]") print("") def test_add(self): """Add operation test""" print("id: " + self.id()) self.assertEqual(calc.add(1, 2), 3) def test_sub(self): """Sub operation test""" print("id: " + self.id()) self.assertEqual(calc.sub(4, 2), 2) def test_mul(self): """Mul operation test""" print("id: " + self.id()) self.assertEqual(calc.mul(2, 5), 10) def test_div(self): """Div operation test""" print("id: " + self.id()) self.assertEqual(calc.div(8, 4), 2) if __name__ == '__main__': unittest.main()

Запустив это модуль в командной строке:

> python -m unittest -v utest_calc.py

Получим следующий результат:

setUpClass ========== test_add (simple_ex.CalcTest) Add operation test . Set up for [Add operation test] id: simple_ex.CalcTest.test_add Tear down for [Add operation test] ok test_div (simple_ex.CalcTest) Div operation test . Set up for [Div operation test] id: simple_ex.CalcTest.test_div Tear down for [Div operation test] ok test_mul (simple_ex.CalcTest) Mul operation test . Set up for [Mul operation test] id: simple_ex.CalcTest.test_mul Tear down for [Mul operation test] ok test_sub (simple_ex.CalcTest) Sub operation test . Set up for [Sub operation test] id: simple_ex.CalcTest.test_sub Tear down for [Sub operation test] ok ========== tearDownClass ---------------------------------------------------------------------- Ran 4 tests in 0.016s OK

Как видно из примера, вначале был запущен метод setUpClass(), потом последовательно (в алфавитном порядке) были выполнены тесты, перед запуском каждого теста выполнялся метод setUp(), по окончании – tearDown(). Каждый метод содержит docstring в виде комментария в первой строке. Для доступа к этому описанию использовался метод shortDescription(). В теле теста присутствует строка, печатающая идентификатор, получаемый с помощью функции id().