Тестирование программы, JUnit
JUnit — библиотека для модульного тестирования программ Java. Созданный Кентом Беком и Эриком Гаммой, JUnit принадлежит семье фреймворков xUnit для разных языков программирования, берущей начало в SUnit Кента Бека для Smalltalk. JUnit породил экосистему расширений — JMock, EasyMock, DbUnit, HttpUnit и т. д.
Библиотека JUnit была портирована на другие языки, включая PHP (PHPUnit), C# (NUnit), Python (PyUnit), Fortran (fUnit), Delphi (DUnit), Free Pascal (FPCUnit), Perl (Test::Unit), C++ (CPPUnit), Flex (FlexUnit), JavaScript (JSUnit).
JUnit – это Java фреймворк для тестирования, т. е. тестирования отдельных участков кода, например, методов или классов. Опыт, полученный при работе с JUnit, важен в разработке концепций тестирования программного обеспечения.
Пример теста JUnit
Необходимость использования JUnit
JUnit позволяет в любой момент быстро убедиться в работоспособности кода. Если программа не является совсем простой и включает множество классов и методов, то для её проверки может потребоваться значительное время. Естественно, что данный процесс лучше автоматизировать. Использование JUnit позволяет проверить код программы без значительных усилий и не занимает много времени.
Юнит тесты классов и функций являются своего рода документацией к тому, что ожидается в результате их выполнения. И не просто документацией, а документацией которая может автоматически проверять код на соответствие предъявленным функциям. Это удобно, и часто тесты разрабатывают как вместе, так и до реализации классов. Разработка через тестирование — крайне популярная технология создания серьезного программного обеспечения.
Виды тестирования и место JUnit тестирования в классификации
Тестирование программного обеспечение можно разделить на два вида:
Во время тестирования программы как черного ящика внутренняя структура приложения в расчет не принимается. Все, что имеет значение, это функциональность, которую приложение должно обеспечить. При тестировании программы как белого ящика во внимание принимается внутренняя структура, т.е. класс и методы. Кроме этого, тестирование можно разделить на четыре уровня:
Юнит тестирование по определению является тестированием белого ящика.
JUnit 3
Для создания теста следует наследовать тест-класс TestCase, переопределить методы setUp и tearDown при необходимости, ну и самое главное — разработать тестовые методы, наименование которых должно начинаться с аббривиатуры «test». При запуске теста сначала создается экземляр тест-класса (для каждого теста в классе отдельный экземпляр класса), затем выполняется метод setUp, запускается сам тест, ну и в завершение выполняется метод tearDown. Если какой-либо из методов вызывает исключение, тест считается провалившимся.
Примечание : тестовые методы должны быть public void, могут быть static.
Тесты состоят из выполнения некоторого кода и проверок. Проверки чаще всего выполняются с помощью класса Assert хотя иногда используют ключевое слово assert.
В качестве примера рассмотрим утилиту для работы со строками, включающую методы для проверки пустой строки и представления последовательности байт в виде 16-ричной строки:
Дополнительные возможности, TestSuite
JUnit 3 имеет несколько дополнительных возможностей. Например, можно группировать тесты. Для этого необходимо использовать класс TestSuite:
Можно исполнение теста повторить несколько раз. Для этого используется RepeatedTest :
Наследуя тест-класс от ExceptionTestCase, можно проверить код на выброс исключения :
JUnit 4
В JUnit 4 добавлена поддержка новых возможностей из Java 5.0; тесты могут быть объявлены с помощью аннотаций. При этом существует обратная совместимость с предыдущей версией фреймворка. Практически все рассмотренные выше примеры будут работать и в JUnit 4 за исключением RepeatedTest, который отсутствует в новой версии.
Какие внесены изменения появились в JUnit 4? Рассмотрим тот же пример, но уже с использованием новых возможностей :
Примеры использования аннотаций с параметрами, JUnit Test :
Игнорирование выполнения теста, JUnit Ignore
Если один из тестов по какой-либо серьезной причине необходимо отключить, например, тест постоянно завершается с ошибкой. Исправление теста можно отложить до светлого будущего аннотированием @Ignore. Если поместить эту аннотацию на класс, то все тесты в этом классе будут отключены.
Правила тастирования, JUnit Rule
JUnit позволяет использовать определенные разработчиком правила до и после выполнения теста, которые расширяют функционал. Например, есть встроенные правила для задания таймаута для теста (Timeout), для задания ожидаемых исключений (ExpectedException), для работы с временными файлами(TemporaryFolder) и др.
Для объявления правила необходимо создать public не static поле типа производного от MethodRule и аннотировать его с помощью ключевого слова Rule.
Наборы тестов, JUnit Suite, SuiteClasses
Запуск теста может быть сконфигурирован с помощью аннотации @RunWith. Тестовые классы, которые содержат в себе тестовые методы, можно объединить в наборы тестов (Suite). Например, создано два класса тестирования объектов : TestFilter, TestConnect. Эти два тестовых класса можно объединить в один тестовый класс TestWidgets.java :
Для настройки запускаемых тестов используется аннотация @SuiteClasses, в которую включены тестовые классы.
Аннотация Categories
Аннотация Categories позволяет объединить тесты в категории (группы). Для этого в тесте определяется категория @Category, после чего настраиваются запускаемые категории тестов в Suite. Это может выглядеть следующим образом:
Аннотация, JUnit Parameterized
Аннотация Parameterized позволяет использовать параметризированные тесты. Для этого в тест-классе объявляется статический метод, возвращающий список данных, которые будут использованы в качестве аргументов конструктора класса.
Параметризирование метода : Theories.class, DataPoints, DataPoint, Theory
Аннотация Theories параметризирует тестовый метод, а не конструктор. Данные помечаются с помощью @DataPoints и @DataPoint, тестовый метод — с помощью @Theory. Тест, использующий этот функционал, может выглядеть примерно следующим образом :
Порядок выполнения тестов
Если необходимо выполнить тест в определенном порядке, то можно воспользоваться аннотацией @FixMethodOrder(MethodSorters.NAME_ASCENDING), определенной в JUnit 4.11. Например :
В противном случае можно использовать следующие 2 подхода.
Список основных аннотаций
| Аннотация | Описание |
|---|---|
| @Test public void testMethod() | метод является тестовым |
| @Test(timeout=100) public void testMethod() | если время выполнения превысит параметр timeout, то тест будет завершен неудачно |
| @Test (expected = MyException.class) public void testMethod() | метод должен выбросить исключение принадлежащие к классу MyException, в противном случае тест будет завершен неудачно |
| @Ignore public void testMethod() | игнорировать тестовый метод |
| @BeforeClass public static void testMethod() | метод вызывающийся один раз для класса перед выполнением тестовых методов; здесь можно разместить инициализацию которую нужно выполнять только один раз, например, прочитать данные, которые будут использоваться в тестовых методах или создать соединение с базой данных |
| @AfterClass public static void testMethod() | метод вызывающийся один раз для класса после выполнения тестовых методов; здесь можно разместить деинициализацию которую нужно выполнять только один раз, например, закрыть соединение с базой данных или удалить данные, которые больше не нужны |
| @Before public static void beforeMethod() | метод, вызывающийся перед каждым тестовым методом в тестовом классе; здесь можно выполнить необходимую инициализацию, например, выставить начальные параметры |
| @After public static void afterMethod() | метод, вызывающийся после каждого тестового метода в тестовом классе; здесь можно выполнить необходимую деинициализацию, например, удалить данные, которые больше не нужны |
Список типов проверок Asserts
| Тип проверки | Описание |
|---|---|
| fail() fail(String message) | прерывание теста с ошибкой, т.е. тест будет неудачным |
| assertTrue(boolean condition) assertTrue(java.lang.String message, boolean condition) | проверка на равенство условия condition значению true |
| assertFalse(boolean condition) assertFalse(String message, boolean condition) | проверка на равенство условия condition значению false |
| assertEquals( expected, actual) assertEquals(String message, expected, actual) | проверка на равенство; — это Object, int, double и т.д. |
| assertArrayEquals(byte[] expecteds, byte[] actuals) assertArrayEquals(String message, [] expecteds, [] actuals) | проверка массивов на равенство; аналогично assertEquals; — это Object, int, double и т.д. |
| assertNotNull(Object object) assertNotNull(String message, Object object) | проверка, что Object не null |
| assertNull(Object object) assertNull(String message, Object object) | проверка, что Object null |
| assertSame(Object expected, Object actual) assertSame(String message, Object expected, Object actual) | проверка на равенство двух объектов expected и actual, т.е. один и тот же объект |
Пример JUnit тестирования
Тестовый класс с несколькими сценариями будет иметь следующий вид :
Метод calls тестирует правильность счетчика вызовов. Метод factorial проверяет правильность вычисления факториала для некоторых стандартных значений. Метод factorialNegative проверяет, что для отрицательных значений факотриала будет брошен IllegalArgumentException. Метод todo будет проигнорирован.
В заключении следует отметить, что в статье представлены не все возможности использования JUnit. Но как видно из приведенных примеров, фреймворк достаточно прост в использовании, дополнительных возможностей немного, но есть возможность расширения с помощью правил и запускалок.
JUnit — введение в юнит-тесты. Пример JUnit Hello world
Введение в юнит-тестирование с помощью библиотеки JUnit. Пример JUnit Hello world
Используемые технологии и библиотеки
1. Описание задачи
Создать юнит тесты для приложения «калькулятор». Показать применение базовых аннотаций JUnit,
2. Структура проекта
3. pom.xml
Для подключения библиотеки JUnit используется maven.
Других зависимостей подключать не нужно.
4. Calculator
Наш простой класс, описывающий калькулятор описан чуть ниже.
5. Создание тестирующих классов
В IntelliJ IDEA можно создать тестирующих класс автоматически. Для этого можно нажать alt + enter на классе и выбрать «Create test». Далее выбрать методы, которые нужно будет протестировать. В результате будет создан класс CalculatorTest с тремя выбранными методами. Эти методы необходимо реализовать самостоятельно.
6. CalculatorTest
После создания тестирующего класса нам необходимо реализовать методы, которые мы хотим проверить. Так же были добавлены другие методы, которые будут демонстрировать работу базовых JUnit аннотаций.
Тестирование в Java. JUnit
Сегодня все большую популярность приобретает test-driven development(TDD), техника разработки ПО, при которой сначала пишется тест на определенный функционал, а затем пишется реализация этого функционала. На практике все, конечно же, не настолько идеально, но в результате код не только написан и протестирован, но тесты как бы неявно задают требования к функционалу, а также показывают пример использования этого функционала.
Итак, техника довольно понятна, но встает вопрос, что использовать для написания этих самых тестов? В этой и других статьях я хотел бы поделиться своим опытом в использовании различных инструментов и техник для тестирования кода в Java.
Ну и начну с, пожалуй, самого известного, а потому и самого используемого фреймворка для тестирования — JUnit. Используется он в двух вариантах JUnit 3 и JUnit 4. Рассмотрю обе версии, так как в старых проектах до сих пор используется 3-я, которая поддерживает Java 1.4.
Я не претендую на автора каких-либо оригинальных идей, и возможно многим все, о чем будет рассказано в статье, знакомо. Но если вам все еще интересно, то добро пожаловать под кат.
JUnit 3
Для создания теста нужно унаследовать тест-класс от TestCase, переопределить методы setUp и tearDown если надо, ну и самое главное — создать тестовые методы(должны начинаться с test). При запуске теста сначала создается экземляр тест-класса(для каждого теста в классе отдельный экземпляр класса), затем выполняется метод setUp, запускается сам тест, ну и в завершение выполняется метод tearDown. Если какой-либо из методов выбрасывает исключение, тест считается провалившимся.
Примечание: тестовые методы должны быть public void, могут быть static.
Сами тесты состоят из выполнения некоторого кода и проверок. Проверки чаще всего выполняются с помощью класса Assert хотя иногда используют ключевое слово assert.
Рассмотрим пример. Есть утилита для работы со строками, есть методы для проверки пустой строки и представления последовательности байт в виде 16-ричной строки:
Напишем для нее тесты, используя JUnit 3. Удобнее всего, на мой взгляд, писать тесты, рассматривая нейкий класс как черный ящик, писать отдельный тест на каждый значимый метод в этом классе, для каждого набора входных параметров какой-то ожидаемый результат. Например, тест для isEmpty метода:
Можно разделить данные и логику теста, перенеся создание данных в метод setUp:
Дополнительные возможности
Кроме того, что было описано, есть еще несколько дополнительных возможностей. Например, можно группировать тесты. Для этого нужно использовать класс TestSuite:
Можно запустить один и тот же тест несколько раз. Для этого используем RepeatedTest:
Наследуя тест-класс от ExceptionTestCase, можно проверить что-либо на выброс исключения:
Как видно из примеров все довольно просто, ничего лишнего, минимум нужный для тестирования(хотя недостает и некоторых нужных вещей).
JUnit 4
Здесь была добавлена поддержка новых возможностей из Java 5, тесты теперь могут быть объявлены с помощью аннотаций. При этом существует обратная совместимость с предыдущей версией фреймворка, практически все рассмотренные выше примеры будут работать и здесь(за исключением RepeatedTest, его нет в новой версии).
Итак, что же поменялось?
Основные аннотации
Рассмотрим тот же пример, но уже используя новые возможности:
Если какой-либо тест по какой-либо серьезной причине нужно отключить(например, этот тест постоянно валится, но его исправление отложено до светлого будущего) его можно зааннотировать @Ignore. Также, если поместить эту аннотацию на класс, то все тесты в этом классе будут отключены.
Правила
Кроме всего вышеперечисленного есть довольно интересная вещь — правила. Правила это некое подобие утилит для тестов, которые добавляют функционал до и после выполнения теста.
Например, есть встроенные правила для задания таймаута для теста(Timeout), для задания ожидаемых исключений(ExpectedException), для работы с временными файлами(TemporaryFolder) и д.р. Для объявления правила необходимо создать public не static поле типа производного от MethodRule и зааннотировать его с помощью Rule.
Также в сети можно найти и другие варианты использования. Например, здесь рассмотрена возможность параллельного запуска теста.
Запускалки
Но и на этом возможности фреймворка не заканчиваются. То, как запускается тест, тоже может быть сконфигурировано с помощью @RunWith. При этом класс, указанный в аннотации должен наследоваться от Runner. Рассмотрим запускалки, идущие в комплекте с самим фреймворком.
JUnit4 — запускалка по умолчанию, как понятно из названия, предназначена для запуска JUnit 4 тестов.
JUnit38ClassRunner предназначен для запуска тестов, написанных с использованием JUnit 3.
SuiteMethod либо AllTests тоже предназначены для запуска JUnit 3 тестов. В отличие от предыдущей запускалки, в эту передается класс со статическим методом suite возвращающим тест(последовательность всех тестов).
Suite — эквивалент предыдущего, только для JUnit 4 тестов. Для настройки запускаемых тестов используется аннотация @SuiteClasses.
Enclosed — то же, что и предыдущий вариант, но вместо настройки с помощью аннотации используются все внутренние классы.
Categories — попытка организовать тесты в категории(группы). Для этого тестам задается категория с помощью @Category, затем настраиваются запускаемые категории тестов в сюите. Это может выглядеть так:
Parameterized — довольно интересная запускалка, позволяет писать параметризированные тесты. Для этого в тест-классе объявляется статический метод возвращающий список данных, которые затем будут использованы в качестве аргументов конструктора класса.
Theories — чем-то схожа с предыдущей, но параметризирует тестовый метод, а не конструктор. Данные помечаются с помощью @DataPoints и @DataPoint, тестовый метод — с помощью Theory. Тест использующий этот функционал будет выглядеть примерно так:
Как и в случае с правилами, в сети можно найти и другие варианты использования. Например, здесь рассмотрена та же возможность паралельного запуска теста, но с использованием запускалок.
Вывод
Это, конечно же, не все, что можно было сказать по JUnit-у, но я старался вкратце и по делу. Как видно, фреймворк достаточно прост в использовании, дополнительных возможностей немного, но есть возможность расширения с помощью правил и запускалок. Но несмотря на все это я все же предпочитаю TestNG с его мощным функционалом, о котором и расскажу в следующей статье.
Основы JUnit
Когда делаешь первые попытки писать юнит-тесты обычно обычно сталкиваешься с проблемой начинания: вроде бы документация прочитана, цель ясна, а с чего начинать — не понятно.
Попробуем вместе написать простой юнит-тест, для более-менее настоящего класса, в котором испытаем почти весь базовый функционал JUnit.
Подготовка
Создадим пустой maven проект:
Класс для тестирования
Поскольку я обещал почти настоящий пример, придётся написать хоть сколько-то полезный класс. Пускай это будем набор утилит для работы со строками:
Тесты
Название тестовых методов так же могут быть любыми, однако для повышения читаемости кода, рекомендуется начинать их с префикса test * и отражать в названии суть теста.
Первый юнит-тест
В первом юнит-тесте строка
и есть входные данные, которые мы отдаём в проверяемую функцию.
Эталонные данные определены в следующей строке:
Вызываем проверяемый код и сохраняем результат его работы:
Наконец самая главная часть теста, проверка:
Однако с сообщением результаты тестирования становятся гораздо приятнее при чтении.
Более того, сам юнит-тест уже является краткой и понятной документацией к функции. В четырёх строках чётко и однозначно написано, как ведёт себя функция: возвращает новый строковый объект, значение которого является переданным ей числом с плавающей запятой, записанное в десятичной системе счисления.
А самый главный бонус юнит-тестирования, это фиксация поведения кода. Вы знаете, прямо сейчас, что функция ведёт себя определённым образом. И код, который её использует, полагается на это поведение. Если Когда вы захотите изменить эту функцию, юнит-тест будет вам гарантировать, что
поведение функции осталось таким же (либо тест провалится). Следовательно остальной код не заметит изменения реализации функции, а это значит, что с этого момента вы можете спокойной менять любую часть кода: юнит-тесты не позволят вам что-нибудь сломать.
Второй юнит-тест
Следующий юнит-тест напишем для обратной функции преобразования строки в число с плавающей запятой:
JUnit — Краткое руководство
Тестирование — это процесс проверки функциональности приложения на предмет его соответствия требованиям. Модульное тестирование входит в картину на уровне разработчиков; это тестирование отдельного объекта (класса или метода). Модульное тестирование играет решающую роль в оказании помощи софтверной компании в предоставлении качественных продуктов своим клиентам.
Модульное тестирование может быть выполнено двумя способами — вручную и автоматически.
| Ручное тестирование | Автоматизированное тестирование |
|---|---|
| Выполнение тестовых случаев вручную без какой-либо поддержки инструмента называется ручным тестированием. | Получение поддержки инструмента и выполнение тестовых случаев с использованием инструмента автоматизации называется автоматизацией тестирования. |
| Отнимает много времени и утомительно — так как тесты выполняются человеческими ресурсами, это очень медленно и утомительно. | Быстро — автоматизация запускает тестовые случаи значительно быстрее, чем человеческие ресурсы. |
| Огромные инвестиции в человеческие ресурсы — поскольку тестовые примеры должны выполняться вручную, для ручного тестирования требуется больше тестировщиков. | Меньше инвестиций в человеческие ресурсы. Тестовые случаи выполняются с использованием средств автоматизации, поэтому для тестирования автоматизации требуется меньше тестеров. |
| Менее надежный — ручное тестирование менее надежно, так как оно должно учитывать человеческие ошибки. | Надежнее — автоматические тесты точны и надежны. |
| Непрограммируемый — не может быть никакого программирования для написания сложных тестов для извлечения скрытой информации. | Программируемый — тестировщики могут программировать сложные тесты, чтобы выявлять скрытую информацию. |
Что такое Юнит?
JUnit — это инфраструктура модульного тестирования для языка программирования Java. Он играет решающую роль при разработке на основе тестов и представляет собой семейство платформ модульного тестирования, известных под общим названием xUnit.
JUnit продвигает идею «сначала тестирование, а затем кодирование», которая делает упор на настройке тестовых данных для фрагмента кода, который можно сначала протестировать, а затем реализовать. Этот подход похож на «немного протестировать, немного кодировать, немного протестировать, немного кодировать». Это увеличивает производительность программиста и стабильность программного кода, что, в свою очередь, снижает нагрузку на программиста и время, затрачиваемое на отладку.
Особенности JUnit
JUnit — это платформа с открытым исходным кодом, которая используется для написания и запуска тестов.
Предоставляет аннотации для определения методов испытаний.
Предоставляет утверждения для тестирования ожидаемых результатов.
Предоставляет тестовые бегуны для запуска тестов.
Тесты JUnit позволяют писать коды быстрее, что повышает качество.
Юнит элегантно прост. Это менее сложный и занимает меньше времени.
Тесты JUnit можно запускать автоматически, они проверяют свои результаты и предоставляют немедленную обратную связь. Нет необходимости вручную прочесывать отчет с результатами теста.
Тесты JUnit могут быть организованы в наборы тестов, содержащие тестовые наборы и даже другие наборы тестов.
JUnit отображает ход выполнения теста на зеленой полосе, если тест проходит гладко, и становится красным при сбое теста.
JUnit — это платформа с открытым исходным кодом, которая используется для написания и запуска тестов.
Предоставляет аннотации для определения методов испытаний.
Предоставляет утверждения для тестирования ожидаемых результатов.
Предоставляет тестовые бегуны для запуска тестов.
Тесты JUnit позволяют писать коды быстрее, что повышает качество.
Юнит элегантно прост. Это менее сложный и занимает меньше времени.
Тесты JUnit можно запускать автоматически, они проверяют свои результаты и предоставляют немедленную обратную связь. Нет необходимости вручную прочесывать отчет с результатами теста.
Тесты JUnit могут быть организованы в наборы тестов, содержащие тестовые наборы и даже другие наборы тестов.
JUnit отображает ход выполнения теста на зеленой полосе, если тест проходит гладко, и становится красным при сбое теста.
Что такое модульный тест?
Модульный тестовый пример — это часть кода, которая гарантирует, что другая часть кода (метода) работает так, как ожидается. Для быстрого достижения желаемых результатов требуется тестовая структура. JUnit — это идеальный фреймворк модульного тестирования для языка программирования Java.
Формальный письменный пример модульного теста характеризуется известными входными данными и ожидаемым выходным сигналом, которые вырабатываются до выполнения теста. Известный вход должен проверять предварительное условие, а ожидаемый результат должен проверять постусловие.
Для каждого требования должно быть не менее двух тестовых случаев — один положительный и один отрицательный. Если у требования есть под-требования, у каждого под-требования должно быть по крайней мере два контрольных примера как положительный и отрицательный.
JUnit — настройка среды
Настройка локальной среды
JUnit — это фреймворк для Java, поэтому самое первое требование — установить JDK на вашем компьютере.
Системные требования
| JDK | 1,5 или выше. |
|---|---|
| объем памяти | Нет минимальных требований. |
| Дисковое пространство | Нет минимальных требований. |
| Операционная система | Нет минимальных требований. |
Шаг 1: Проверьте установку Java на вашем компьютере
Прежде всего, откройте консоль и выполните команду Java в зависимости от операционной системы, с которой вы работаете.
| Операционные системы | задача | команда | |||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Windows | Открытая командная консоль | c: \> Java-версия | |||||||||||||||||||||||||||||||||||||||||||||||||
| Linux | Открытый командный терминал | $ java-версия | |||||||||||||||||||||||||||||||||||||||||||||||||
| макинтош | Открытый терминал | машина: Давайте проверим вывод для всех операционных систем —
Добавьте местоположение компилятора Java в системный путь. Шаг 3: Скачать архив JUnit
Шаг 4: Установите среду JUnitУстановите переменную среды JUNIT_HOME, чтобы она указывала на местоположение базовой директории, где на вашем компьютере хранится JUNIT jar. Предположим, что мы сохранили файл junit4.12.jar в папке JUNIT.
Assert ClassНиже приводится объявление для класса org.junit.Assert — Этот класс предоставляет набор методов утверждения, полезных для написания тестов. Только ошибочные утверждения записываются. Вот некоторые из важных методов класса Assert:
|
