{"id":88942,"date":"2019-02-27T13:00:41","date_gmt":"2019-02-27T11:00:41","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=88942"},"modified":"2019-02-26T10:42:01","modified_gmt":"2019-02-26T08:42:01","slug":"writing-unit-tests-time-junit-parameters","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/02\/writing-unit-tests-time-junit-parameters.html","title":{"rendered":"Writing better unit tests in less time with Junit Parameters"},"content":{"rendered":"

Most of people understand the importance and benefits of unit tests and why you should have them in projects you work on. Also, most of people don’t like to write unit tests in projects they work on. TDD people are on other side of specter of course, but from my experience they are minority in IT industry.<\/p>\n

When it comes to me, well I am with most people :-). I know why having unit tests is good, and how it will improving quality of code and projects. I know why you should invest in them, however I am not super happy to write unit tests, that isn’t the thing that keep me wake at night. I prefer much more to create cool software and solve complex problems, then writing unit tests. That is why I am always on lookout on things that can help me in getting more and better unit tests, with less work from my side ,since in the end you should have unit tests in your projects.<\/p>\n

One of those things that can help you to write better unit test with less time spent is Junit Params.<\/p>\n

Why should you care about Junit Params?<\/h3>\n

Let’s us imagine that we have simple class Person, which has first name and last name. Business requirement is that first and last name can’t be null or empty strings.<\/p>\n

We can end up with some class similar to this one<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> Person {<\/code><\/div>\n
 <\/div>\n
    <\/code>private<\/code> final<\/code> String firstName;<\/code><\/div>\n
    <\/code>private<\/code> final<\/code> String lastName;<\/code><\/div>\n
 <\/div>\n
    <\/code>public<\/code> Person(String first, String last) {<\/code><\/div>\n
        <\/code>if<\/code>(first == <\/code>null<\/code> || first.trim().isEmpty() || last == <\/code>null<\/code> || last.trim().isEmpty() ) {<\/code><\/div>\n
            <\/code>throw<\/code> new<\/code> RuntimeException(<\/code>\"bad input\"<\/code>);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
        <\/code>this<\/code>.firstName = first;<\/code><\/div>\n
        <\/code>this<\/code>.lastName = last;<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
 <\/div>\n
    <\/code>public<\/code> String getFirstName() {<\/code><\/div>\n
        <\/code>return<\/code> firstName;<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
 <\/div>\n
    <\/code>public<\/code> String getLastName() {<\/code><\/div>\n
        <\/code>return<\/code> lastName;<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Next step is to make sure that code works as intended and that we took into account all corner cases.<\/p>\n

We would of course want to cover all that possibilities using unit tests, but if you think about it we will have a lot of repeated code where we test first name for all possibilities, and then last name, and then all combinations and so on if we want to cover all edge cases. We will end up with a lot more code in unit tests then code in our business logic for this simple class.<\/p>\n

Let’s us look how JUnit Params can help us with this.<\/p>\n

Init setup<\/h3>\n

In order to use Junit Params you just need to add dependency like for any other library<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n<\/td>\n
\n
\n
<dependency><\/code><\/div>\n
    <\/code><groupId>pl.pragmatists<\/groupId><\/code><\/div>\n
    <\/code><artifactId>JUnitParams<\/artifactId><\/code><\/div>\n
    <\/code><version><\/code>1.1<\/code>.<\/code>1<\/code><\/version><\/code><\/div>\n
    <\/code><scope>test<\/scope><\/code><\/div>\n
<\/dependency><\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

After this we can start using JUnit Params in our unit tests

<\/div> <\/div><\/p>\n

JUnit tests using JUnit Params<\/h3>\n

Let us write now few unit test by using JUnit Params.<\/p>\n

Create simple test class PersonTest<\/em> and add @RunWith(JUnitParamsRunner.class<\/strong>)<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
@RunWith<\/code>(JUnitParamsRunner.<\/code>class<\/code>)<\/code><\/div>\n
public<\/code> class<\/code> PersonTest {<\/code><\/div>\n
    <\/code>.......<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Now we can write simple unit test to validate our class. Let us first check if all is good if we pass null as first name<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
@Test<\/code>(expected = RuntimeException.<\/code>class<\/code>)<\/code><\/div>\n
public<\/code> void<\/code> fistNameNull() {<\/code><\/div>\n
    <\/code>Person p = <\/code>new<\/code> Person(<\/code>null<\/code>,<\/code>\"dummyLast\"<\/code>);<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Great thing about JUnit Params is that we can still write standard unit tests and combine them with JUnit Params.<\/p>\n

In order to leverage JUnit params on this unit test I just need to add @Parameters<\/strong> with appropriate values, and then it would look something like this<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
@Test<\/code>(expected = RuntimeException.<\/code>class<\/code>)<\/code><\/div>\n
@Parameters<\/code>({ <\/code>\"\"<\/code>,<\/code>\" \"<\/code> ,<\/code>\"  \"<\/code>, <\/code>\"   \"<\/code>})<\/code><\/div>\n
public<\/code> void<\/code> fistNameParamaters(String param) {<\/code><\/div>\n
    <\/code>Person p = <\/code>new<\/code> Person(param,<\/code>\"dummyLast\"<\/code>);<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

with this code I made 4 unit tests, which validate my code for values “”,” “, ” ” and ” “.<\/p>\n

This shows already how useful JUnit Params are since you write only one unit test and it will be executed for all different possibilities of your params.<\/p>\n

Passing parameters to multiple input parameters<\/h3>\n

What happens if we want to pass parameters for both input values, first name and last name. In that case we would do something like this<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n<\/td>\n
\n
\n
@Test<\/code>(expected = RuntimeException.<\/code>class<\/code>)<\/code><\/div>\n
@Parameters<\/code>({ <\/code>\" \"<\/code> ,<\/code>\"    \"<\/code>, <\/code>\/\/ firstName, lastName<\/code><\/div>\n
            <\/code>\"  \"<\/code>,<\/code>\"\"<\/code>,<\/code><\/div>\n
            <\/code>\"   \"<\/code>, <\/code>\"  \"<\/code>,<\/code><\/div>\n
            <\/code>\"    \"<\/code>,<\/code>\" \"<\/code>})<\/code><\/div>\n
public<\/code> void<\/code> fistNameLastNameParamaters(String first, String last) {<\/code><\/div>\n
    <\/code>Person p = <\/code>new<\/code> Person(first, last);<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

since there are two input parameters, values provided will be split in pair of two and used as input.<\/p>\n

As you can see providing input for multiple parameters is very easy, although in this way we need to provide all combinations that we want to test.<\/p>\n

Passing parameters to multiple input parameters in user friendly way<\/h3>\n

If we are honest although test above works fine for multiple input paramaters, it isn’t very user friendly. Let us fix that in next example<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
@Test<\/code>(expected = RuntimeException.<\/code>class<\/code>)<\/code><\/div>\n
@Parameters<\/code>({ <\/code>\" |    \"<\/code> , <\/code>\"  |\"<\/code>, <\/code>\"   |  \"<\/code>, <\/code>\"    | \"<\/code>})<\/code><\/div>\n
public<\/code> void<\/code> fistNameLastNameParamaters2(String first, String last) {<\/code><\/div>\n
    <\/code>Person p = <\/code>new<\/code> Person(first, last);<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

now it is much more clear which value will be used for which input parameter in every iteration.<\/p>\n

Using non string values as input parameters<\/h3>\n

So far all parameters were Strings. What if our input parameter isn’t a String or something that is easily convert from\/to String, for example null<\/em> value.<\/p>\n

In that case we can use named parameter<\/em><\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n<\/td>\n
\n
\n
@Test<\/code>(expected = RuntimeException.<\/code>class<\/code>)<\/code><\/div>\n
@Parameters<\/code>(named = <\/code>\"emptyStrings\"<\/code>)<\/code><\/div>\n
public<\/code> void<\/code> namedParamaters(String first, String last) {<\/code><\/div>\n
    <\/code>Person p = <\/code>new<\/code> Person(first, last);<\/code><\/div>\n
}<\/code><\/div>\n
 <\/div>\n
@NamedParameters<\/code>(<\/code>\"emptyStrings\"<\/code>)<\/code><\/div>\n
private<\/code> Object[] emptyStrings() {<\/code><\/div>\n
    <\/code>return<\/code> new<\/code> Object[]{<\/code><\/div>\n
            <\/code>new<\/code> Object[]{<\/code>null<\/code>, <\/code>\"\"<\/code>},<\/code><\/div>\n
            <\/code>new<\/code> Object[]{<\/code>\"\"<\/code>, <\/code>null<\/code>},<\/code><\/div>\n
            <\/code>new<\/code> Object[]{<\/code>\" \"<\/code>, <\/code>\"  \"<\/code>},<\/code><\/div>\n
            <\/code>new<\/code> Object[]{<\/code>\"   \"<\/code>, <\/code>\" \"<\/code>}<\/code><\/div>\n
    <\/code>};<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Reference<\/h3>\n

Code examples mentioned in this post can be found on this url<\/p>\n