Introduction

We often encounter the problem during testing that we do not care about the data correctness, as much as we care about correct algorithm flow. In this situations, we want to check if specific methods were hit and executed. Sometimes we need to go deeper and seek an answer on how often these methods were called or verify that the methods called at all.

The necessary method, which will help us in our testing quest, is called verify() and is part of Mockito testing framework.

Mockito verify verification options

public static  T verify(T mock, VerificationMode mode)

mock is object of type T you are placing into the verify() method for verification. As a second method argument is VerificationMode mode variable, which describes how the mock should be verified. Possible verification modes are:

verify(mock, times(5)).someMethod("was called exactly five times");
verify(mock, never()).someMethod("was never called");
verify(mock, atLeast(5)).someMethod("was called at least five times");
verify(mock, atLeastOnce()).someMethod("was called at least once");
verify(mock, atMost(5)).someMethod("was called at most five times");

There is also one special VerificationMode mode called only(). This mode verifies that no other method was called on the mock so far.

verify(mock, only()).someMethod("only someMethod was called");

Mockito verify verification modes in action

In order to test individual verification modes, we will write a simple test. For testing purposes it will consist from two classes. (Both are inner private classes for MockitoVerifyTest.java.) First will be a fake class Account which trough dependency injection will use second class Counter. Counter class will be used as a Mock in our test.

Here is a Counter class:

private class Counter {

    private int counter;

    public Counter() {
        this.counter = 0;
    }

    public void increment() {
        this.counter++;
    }

    public void reset() {
        this.counter = 0;
    }

    public int getCount() {
        return this.counter;
    }
}

And here is the Account class:

private class Account {

    private Counter counter;

    public Account(Counter counter) {
        this.counter = counter;
    }

    public void incrementCounter() {
        this.counter.increment();
    }

    public void resetCounter() {
        this.counter.reset();
    }

    public int getCounterValue() {
        return this.counter.getCount();
    }
}

And finally, here is an exemplary test where you can see usage of individual verification modes:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;

import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atMost;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

@RunWith(MockitoJUnitRunner.class)
public class MockitoVerifyTest {

    @Mock
    Counter counter;

    @Test
    public void testMockitoVerifyMethodCalls() {

        Account account = new Account(counter);

        // Verification using only() and atLeastOnce()
        account.incrementCounter();
        Mockito.verify(counter, only()).increment();
        Mockito.verify(counter, atLeastOnce()).increment();

        // Verification using times(X)
        for (int i = 0; i < 4; i++) {
            account.incrementCounter();
        }
        Mockito.verify(counter, times(5)).increment();

        // Verification using atLeast(X), atMost(X), never()
        for (int i = 0; i < 5; i++) {
            account.incrementCounter();
        }
        Mockito.verify(counter, atLeast(5)).increment();
        Mockito.verify(counter, atMost(10)).increment();
        Mockito.verify(counter, never()).getCount();
    }
}

Let's discuss little but example code.

Account account = new Account(counter);

// Verification using only() and atLeastOnce()
account.incrementCounter();
Mockito.verify(counter, only()).increment();
Mockito.verify(counter, atLeastOnce()).increment();

First, we will create new instance of Account class which trough dependency injection is injected with Mock instance of our Counter class.

As first we verify that there was no method, except increment() method, has been called on our mock at all. And as second verification, we will check that it was called at least once,

for (int i = 0; i < 4; i++) {
    account.incrementCounter();
}
Mockito.verify(counter, times(5)).increment();

Now we call incrementCounter() method four more times, remember we already called it once, and we will check that it was mock method injected to instance was called exactly five times.

for (int i = 0; i < 5; i++) {
    account.incrementCounter();
}
Mockito.verify(counter, atLeast(5)).increment();
Mockito.verify(counter, atMost(10)).increment();
Mockito.verify(counter, never()).getCount();

In the last section, we are incrementing the counter again five more times, and now we are checking if it was called at least five times and at most ten times.

On the last line we are checking method call for Mock' getCount() method that was never called.

Conclusion

This article contains a straightforward test on which we have demonstrated how to use Mockito verify method for mock' method call verification.

As always, you can find all our examples on our GitHub project!

Introduction

Checking list equality is a widespread problem; we often need to compare the list elements against each other. Comparison and assertion occur many times during the testing when we need to assert results with predefined expectations.

Two lists equality

At first, some might think, that for equality of two lists is conditioned by lists containing the same elements. This way of thinking is not entirely true. Single look into the Java documentations for List.equals() method will uncover us true meaning of list equality:

… two lists are defined to be equal if they contain the same elements in the same order.

Therefore, we need to compare the lists’ elements mutually, but we also need to check the order of the elements in the lists reciprocally.

So first, let’s take a good look at how not to do a list equality check.

Compare two list with the bruteforce

Following lines of code are placed here only for demonstration purposes. For all cost, you must avoid such hideous brute force solution in your code.

private boolean compareLists(final List list1,final List list2) {
    if(list1.size() == list2.size()) {
        if(list1.isEmpty() && list2.isEmpty()) {
            return true;
        }
        for(int i = 0; i < list1.size(); i++) {
            if(!list1.get(i).equals(list2.get(i))) {
                return false;
            };
        }
        return true;
    }
    return false;
}

The reason why to not use it in your code is that this code is basically List interface implementation of the equal() method. Therefore all you need to use for comparing two lists is to call equal() method.

private boolean compareLists(final List list1,final List list2) {
    return list1.equals(list2);
}

Interface method definition ensures that the equals method works through different implementations of the List interface in a same way.

Framework usage

For testing purposes, it is probably better to use some of the available Java frameworks for testing, which can give us more options in List testing.

In our examples, we will play with the following code snippet based on user entities belonging to different groups. We will compare lists are figure out if all users are members of all groups.

List users = Arrays.asList("John Doe", "Tom Smith", "Paul Iron", "George Silver");
List moderators = Arrays.asList("John Doe", "Tom Smith", "Paul Iron", "George Silver");
List admins = Arrays.asList("John Doe", "Tom Smith", "Paul Iron", "George Silver");

JUnit

Rather than using and printing equals for tests, it is better to use assert methods. JUnit testing framework offers us three suitable ways for list equality assertion.

• assertEquals(expected, actual) - Asserts that two objects are equal. If they are not, an AssertionError without a message is thrown. If expected and actual are null, they are considered equal.
• assertNotSame(unexpected, actual) - Asserts that two objects do not refer to the same object. If they do refer to the same object, an AssertionError without a message is thrown.
• assertNotEquals(unexpected, actual) - Asserts that two objects are not equals. If they are, an AssertionError without a message is thrown. If unexpected and actual are null, they are considered equal.

@Test
public void testJUnitListAsserts() throws Exception {
    Assert.assertEquals(users, moderators);
    Assert.assertNotSame(users, moderators);
    Assert.assertNotEquals(users, admins);
}

Conclusion

This article has shown you how not to do list assertion and explain how to check and assert two lists equality.

As always, you can find all our examples on our GitHub project!

Here is a working example of DocumentRepositoryTest class for reference:

@RunWith(MockitoJUnitRunner.class)
public final class DocumentRepositoryTest {

    @Mock
    private DocumentRepository documentRepository;

    @Test
    public void testConvertToNewDocument() {
        String paperColor = new String("white");
        Mockito.when(this.documentRepository.getPaperColor()).thenReturn(paperColor);
        String color = this.documentRepository.getDocumentColor();
        Assert.assertThat(color, is(new String("white"));
    }
}

DocumentRepositoryTest class is mocking documentRepository object.

So you are running your test and suddenly you see NullPointerException:

java.lang.NullPointerException at com.your.custom.clazz.Method.insertTest(CustomServiceTest.java:50)

You looked it up, and it seems your test is written correctly. So what might be a problem if you know how the mocking works?

If you are sure by your mocking skills, the issue will be probably somewhere else. And most likely very trivial. Here is a list of 3 things you should check out.

1. Return something for your Mock.

Most likely, you mistyped returning function. You probably wanted to return the value for the mocked object. So instead of when-thenReturn , you might type just when-then. Maybe it was IntelliSense. Maybe you did it accidentally. But for sure, NullPointerException happened because you want something which is not there. Debug and check if you are returning something.

2. Specify Mockito running class

Don’t forget to annotate your Testing class with @RunWith(MockitoJUnitRunner.class). Most of the people just forget to specify the test runner, running class for mocking.

3. You need to annotate the mocking object with the @Mock annotation

If you want to mock an object, you need to annotate the object with @Mock annotation.