Как тестировать void методы java

JUNIT testing void methods

I have a java class full of void methods, and I want to make some unit test to get maximal code coverage.

For example I have this method :

Its poorly named for a reason because I translated the code for better understanding. Each methods verify if the arguments are valid in some way and are well written.

My unit test are covering the small methods fine because I ask them to check if the ErrorFile contains the error message, but I dont see how I can test my method checkIfValidElements, it returns nothing or change nothing. When I run code coverage with Maven, it tells me that the unit test doesent cover this part of my class.

The only way I see is to change this method to return an int or bollean value, like this :

With this method I am able to do an assert equals, but it seems to me that it is futile to do this. The problem is that I have a couple of class that are designed like this and its lowering my unit test coverage %.

7 Answers 7

I want to make some unit test to get maximal code coverage

Code coverage should never be the goal of writing unit tests. You should write unit tests to prove that your code is correct, or help you design it better, or help someone else understand what the code is meant to do.

but I dont see how I can test my method checkIfValidElements, it returns nothing or change nothing.

For example, suppose someone removed the call to:

. or accidentally changed the argument order:

How would you notice those problems? Go from that, and design tests to prove it.

If your method has no side effects, and doesn’t return anything, then it’s not doing anything.

If your method does some computation and returns the result of that computation, you can obviously enough assert that the result returned is correct.

If your code doesn’t return anything but does have side effects, you can call the code and then assert that the correct side effects have happened. What the side effects are will determine how you do the checks.

Источник

How to test void method with Junit testing tools?

I just happen to implement a method void followlink(obj page,obj link) which simply adds page and link to queue. I have unsuccessfully tried to test this kind of method.

All I want is to test that in the queue contains page and link received from followlink method. My test class already extends TestCase. So what is the best way to test such a method?

6 Answers 6

The example given in the FAQ tests that the size of a Collection changes after an item is added.

You could test the size if the queue before and after calling your method, something like:

another thing you might do is start off with an empty queue, call followLink, then dequeue the first item and test its values.

Most likely, your queue is private, so checking the size isn’t going to work. The «design for testing» solution I’ve seen is to make use of package private methods and members instead. Since your junit tests are likely to be in the same package, they’ll have access.

That by itself lets the «queue.length()» side effect test work.

But I’d go further: really, you should consider checking that your method has inserted the correct page and link to your queue. The details for that require more knowledge about how you’re representing (and combining) page and link.

The jMock solution is also very good, though in truth I’m much more familiar with writing my own test harnesses.

Источник

Тестирование в 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 с его мощным функционалом, о котором и расскажу в следующей статье.

Источник

Unit testing a void method

Code

However, I’m not sure what the best way to write a unit test for postLogin is.

Approach 1

Use verify from Mockito to simply verify that the method was called.

Approach 2

Test the side effect of the method call by fetching the value of the user’s shopping cart.

Is one approach better than the other?

5 Answers 5

I would usually prefer method 2.

Why? Because, you want postLogin to change some state of your system, but how it accomplishes this (and which methods it calls internally for this) is merely an implementation detail, nothing your unit test should make any assumptions about. So better make your test just verifying the final state.

I would change getShoppingCart to something like initializeShoppingCart, the purpose of the method should be clear to whoever reads it without the need to check what the method does and side effects like this can cause some surprising behavior for users of the method.

If getShoppingCart is a private method which can not be tested by itself, then I would use approach 2, to make sure that when postLogin is called the desired functionality of getShoppingCart is performed as expected.

When testing a function call (void or not) that has a side effect, it’s most complete to test that the side effect not only occurs, but to check that the side effect (system output or or state change) is the one desired.

You have a bug in postLogin. So the first thing you should do is create a unit test which upon calling postLogin without the expected set of information will «fail».

From the above idea, another alternative from the 2 proposed is to inject the information about the shopping cart as a parameter. If you don’t have the correct information, you throw an unchecked exception. This will make it clear that without the correct details, your method is doomed.

This will require a little change where the client calling the postLogin right now is required to also pass the shopping cart info. To me this is still coherent now that you see they are coupled. This coupling will be done by the caller.

Then you wouldn’t even need to test getShoppingCart inside postLogin because the real method under test is postLogin. It is the one that has the bug and the only one that requires proper fix and validation. With the injected dependency, you will be able to test it easily under different condition and confirm that no error is thrown.

Источник

Модульное тестирование на Java с JUnit 5

Вступление

JUnit – популярная платформа тестирования для Java. Простое использование очень просто, и JUnit 5 привнес некоторые отличия и удобства по сравнению с JUnit 4.

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

Установка JUnit 5

Установка JUnit так же проста, как включение зависимостей:

Как правило, рекомендуемая структура проекта такова:

Различия между JUnit 4 и JUnit 5

Одна из главных идей, лежащих в основе новой версии JUnit, заключается в использовании функций Java 8, представленных на столе (в основном лямбды), чтобы облегчить жизнь каждому. Некоторые незначительные вещи были изменены – необязательное сообщение о том, что утверждение будет напечатано, если оно не удастся, теперь является последним “необязательным” аргументом, а не неудобным первым.

JUnit 5 состоит из трех проектов (платформа JUnit, JUnit Jupiter и JUnit Vintage), поэтому будет несколько разных импортных проектов, хотя JUnit Jupiter будет нашим основным направлением.

Некоторые другие различия включают:

Аннотация @Test

Мы будем использовать простой класс калькулятора, чтобы продемонстрировать основные возможности JUnit. На данный момент наш Калькулятор класс выглядит следующим образом:

Он не делает ничего особенного, но позволит нам пройти через этапы тестирования. В соответствии с соглашениями об именовании, класс CalculatorTest рождается:

Аннотация @Test сообщает JVM, что следующий метод является тестом. Эта аннотация необходима перед каждым методом тестирования.

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

Мы запускаем тесты, просто запустив класс CalculatorTest (мы можем это сделать, даже если у него нет метода main ).:

Если бы мы изменили строку assertEquals() на что-то неправильное, например:

Мы получим соответствующее сообщение об ошибке тестирования:

Методы утверждения

Давайте взглянем на утверждения, имеющиеся в нашем распоряжении. Они, как правило, довольно понятны сами по себе:

assertEquals() и assertNotEquals()

assertSame() и assertNotSame()

assertFalse() и assertTrue()

assert Throws() утверждает, что метод выдаст данное исключение, когда столкнется с возвращаемым значением тестируемого метода

утверждение совпадения строк(Список ожидаемый, Список фактический, необязательный Msg) является несколько более сложным методом, поскольку он выполняет несколько шагов, прежде чем объявить, что переданные аргументы не равны, и работает только с Строкой s:

T утверждает, что выбрасывает(класс Ожидаемый тип, исполняемый файл exec, необязательный Msg) проверяет, что выполнение исполняемого файла вызывает исключение Ожидаемого типа и возвращает это исключение. Если исключение не вызвано или если вызванное исключение не относится к ожидаемому типу – тест завершается неудачно. расширяет выбрасываемый> T утверждает, что выбрасывает(класс Ожидаемый тип, исполняемый файл exec, необязательный Msg)

, этот метод выполняет exec в другом потоке и будет

превышен. assert All(Исполняемые… исполняемые файлы) выдает ошибку множественного сбоя

assert All(исполняемые файлы ) выдает ошибку множественного сбоя

делает что-то очень полезное. А именно, если бы мы хотели использовать несколько утверждений в одном тесте (это не обязательно плохо, если мы это сделаем), произошло бы что-то очень раздражающее, если бы все они пошли плохо. Именно: Когда первое утверждение потерпит неудачу, мы не увидим, как прошли два других. Что может быть особенно неприятно, так как вы можете исправить первое утверждение, надеясь, что оно исправит весь тест, только чтобы обнаружить, что второе утверждение также провалилось, только вы этого не видели, так как первое утверждение “скрыло” этот факт: по сути() решает эту проблему, выполняя все утверждения, а затем показывая вам сбой, даже если несколько утверждений не удалось. Переписанная версия будет: Теперь мы получим более информативный результат тестирования:

Но если бы у нас было что-то вроде:

Вы действительно не хотите, чтобы что-то подобное дополнительная загрузка Msg загружалась независимо от того, планирует ли Java ее распечатать.

Это одна из вещей, которые были невозможны до JUnit 5, потому что в то время лямбды не были представлены в Java, и JUnit не мог использовать их полезность.

Аннотации Testng

В этой части мы представим некоторые другие аннотации, помимо необходимой @Test аннотации. Одна вещь, которую мы должны понимать, заключается в том, что для каждого метода тестирования Java создает новый экземпляр класса тестирования.

Это плохая идея объявлять глобальные переменные, которые изменяются в рамках разных методов тестирования, и это особенно плохая идея ожидать любого типа порядка тестирования, нет никаких гарантий, в каком порядке будут выполняться методы тестирования!

Еще одна плохая идея-постоянно инициализировать класс, который мы хотим протестировать, если в этом нет необходимости. Мы скоро увидим, как этого избежать, но перед этим давайте взглянем на доступные аннотации:

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

Что дает нам результат:

Это также показывает нам, что, несмотря на то, что метод addition Test() объявлен первым, это не гарантирует, что он будет выполнен первым.

Другие Аннотации

До JUnit 5 методы тестирования не могли иметь никаких параметров, но теперь они могут. Мы будем использовать их при демонстрации новых аннотаций.

@Отключено

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

Выдает следующие выходные данные для этого метода тестирования:

@Имя дисплея

Еще одна простая аннотация, которая изменяет отображаемое имя метода тестирования.

Аннотация @Tag полезна, когда мы хотим создать “пакет тестов” с выбранными тестами. Теги используются для фильтрации выполняемых тестов:

Поэтому, если бы мы хотели запускать только тесты с тегом “a”, мы бы выбрали “Выполнить” – > “Редактировать конфигурации” и изменили следующие два поля перед запуском теста:

@Повторное тестирование

Имя по умолчанию каждой итерации – “повторение <текущее повторение><всего повторений>”.

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

@@Параметризованный тест

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

Метод будет получать элементы массива один за другим:

@Вложенные

Эта аннотация позволяет нам группировать тесты там, где это имеет смысл. Мы могли бы захотеть отделить тесты, которые имеют дело с сложением, от тестов, которые имеют дело с делением, умножением и т. Д.; И это предоставляет нам простой способ @Полностью отключить определенные группы. Это также позволяет нам попытаться сделать полные английские предложения в качестве результатов теста, что делает его чрезвычайно читабельным.

@testInstance

Эта аннотация используется только для аннотирования тестового класса с помощью @testInstance(Жизненный цикл.PER_CLASS) чтобы указать JUnit запускать все методы тестирования в одном экземпляре тестового класса, а не создавать новый экземпляр класса для каждого метода тестирования.

Допущения

Что дало бы нам результат:

Заключение и советы

JUnit предоставляет нам простой способ управления нашими тестовыми случаями и отделяет тестирование кода от самого кода. Это позволяет нам отслеживать все, что необходимо протестировать, и показывает нам, что не работает аккуратным способом.

Как правило, вы хотите проверить общую причину всего, что можете. Даже простые, прямолинейные методы, просто чтобы убедиться, что они работают так, как должны. Это может быть даже самой важной частью автоматизированного тестирования – поскольку всякий раз, когда вы что-то меняете в своем коде или добавляете новый модуль, вы можете запускать тесты, чтобы увидеть, нарушили ли вы код или нет, чтобы убедиться, что все по-прежнему работает так, как это было до “улучшения”. Конечно, крайние случаи также важны, особенно для более сложных методов.

Источник