JUnit Mockito Interview Questions

@Test
public void convertIntoUpperCase_withInvalidInput_tryCatchIdiom() {
    try {
        exceptionHandling.convertIntoUpperCase("");
        fail("It should throw IllegalArgumentException");
    } catch (IllegalArgumentException e) {
        Assertions.assertThat(e)
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Empty value is passed.");
    }
}

@Test(expected = IllegalArgumentException.class)
public void convertIntoUpperCase_withInvalidInput_testExpected() {
    exceptionHandling.convertIntoUpperCase("");
}

@Test
public void convertIntoUpperCase_withInvalidInput_ExpectedExceptionRule() {
    exception.expect(IllegalArgumentException.class);
    exception.expectMessage("Empty value is passed.");
    exceptionHandling.convertIntoUpperCase("");
}

@RunWith(MockitoJUnitRunner.class)
public class TestClass {
    ...
}

2. MockitoAnnotations.initMocks()
Alternatively, we can enable these annotations programmatically as well, by invoking MockitoAnnotations.initMocks() as in the following example:

@Before
public void init() {
     MockitoAnnotations.initMocks(this);
}

9. How to mock methods with Mockito?1. when/then

when(repository.saveCusomer(any())).thenReturn(true);

Here,
when: when is a static method of the Mockito class which takes an object and its method which needs to be mocked
any(): It’s a matcher which specifies that the method may get a call with any parameter.
thenRetun: What value do you want to return when this method is called with the specified parameters.

package com.onlyfullstack.unittesting.service;

import com.onlyfullstack.unittesting.bean.Customer;
import com.onlyfullstack.unittesting.repository.CustomerRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
 * This class contains usage of Mockito
 */
@RunWith(MockitoJUnitRunner.class)
public class CustomerServiceTest {

    @Mock
    CustomerRepository repository;

    @InjectMocks
    CustomerService customerService;

    @Test
    public void saveCustomer_withValidCustomer() {
        Customer customer = new Customer(6, "QQQ", "Mumbai");
        when(repository.saveCusomer(any())).thenReturn(true);
        Boolean save = customerService.saveCustomer(customer);
        assertThat(true, is(save));
    }

}

We have seen how to use when/thenRetun pattern, lets explore other patterns:

2. when/thenThrow

This method will throw the specified exception when the mocked method is called.

@Test(expected = IllegalStateException.class)
public void saveCustomer_withValidCustomer_when_thenThrow() {
    Customer customer = new Customer(6, "QQQ", "Mumbai");
    when(repository.saveCusomer(any())).thenThrow(new IllegalStateException());
    customerService.saveCustomer(customer);
}

3. When/thenAnswer

public Customer updateCustomer(Customer customer) {
    if (customer == null || customer.getId() < 0) {
        throw new IllegalArgumentException("Invalid Customer details passed.");
    }
    repository.updateCustomer(customer);
    return customer;
}

@Test
public void updateCustomer_doNothing_when() {
    Customer customer = new Customer(6, "QQQ", "Mumbai");
    doNothing().when(repository).updateCustomer(any(Customer.class));
    customerService.updateCustomer(customer);
}

@Test
public void updateCustomer_doAnswer_when() {
    Customer customer = new Customer(6, "QQQ", "Mumbai");
    doAnswer((arguments) -> {
        System.out.println("Inside doAnswer block");
        assertEquals(customer, arguments.getArgument(0));
        return null;
    }).when(repository).updateCustomer(any(Customer.class));
    customerService.updateCustomer(customer);
}

@Test(expected = Exception.class)
public void updateCustomer_doNothing_when() {
    Customer customer = new Customer(6, "QQQ", "Mumbai");
    doThrow(new Exception("Database connection issue"))

            .when(repository).updateCustomer(any(Customer.class));
    customerService.updateCustomer(customer);
}

11. How to verify the mocks?

@Test
public void saveCustomer_withValidCustomer_when_thenReturn() {
    Customer customer = new Customer(6, "QQQ", "Mumbai");
    when(repository.saveCusomer(any())).thenReturn(true);
    Boolean save = customerService.saveCustomer(customer);
    assertThat(true, is(save));
    verify(repository, times(1)).saveCusomer(eq(customer));
}

verify(repository).saveCusomer(any());
verify(repository).saveCusomer(any(Customer.class));
verify(repository).saveCusomer(ArgumentMatchers.any(Customer.class));
verify(repository).saveCusomer(eq(customer));

Verify with the number of times

verify(repository, times(1)). saveCusomer (); //same as normal verify method

verify(repository, atLeastOnce()).saveCusomer (); // must be called at least once

verify(repository, atMost(2)). saveCusomer(); // must be called at most 2 times

verify(repository, atLeast(1)). saveCusomer(); // must be called at least once

verify(repository, never()).getCusomer(); // must never be called

12. How to check the Order of Invocation with verify?

We can use InOrder to verify the order of invocation. We can skip any method to verify, but the methods being verified must be invoked in the same order.

// A. Single mock whose methods must be invoked in a particular order
List singleMock = mock(List.class);

//using a single mock
singleMock.add("was added first");
singleMock.add("was added second");

//create an inOrder verifier for a single mock
InOrder inOrder = inOrder(singleMock);

//following will make sure that add is first called with "was added first, 

//then with "was added second"
inOrder.verify(singleMock).add("was added first");
inOrder.verify(singleMock).add("was added second");

// B. Multiple mocks that must be used in a particular order
List firstMock = mock(List.class);
List secondMock = mock(List.class);

//using mocks
firstMock.add("was called first");
secondMock.add("was called second");

//create inOrder object passing any mocks that need to be verified in order
InOrder inOrder = inOrder(firstMock, secondMock);

//following will make sure that firstMock was called before secondMock
inOrder.verify(firstMock).add("was called first");
inOrder.verify(secondMock).add("was called second");

// Oh, and A + B can be mixed together at will

13. What is difference between @Mock and @Spy?

/*
 We dont need to instantiate the mock List as the @Mock will create and instantiate the list for us
 */
@Mock
private List<String> mockedList;

/*
We need to instantiate the list object as the @Spy will use the real objects method if we dont mock them
 */
@Spy
private List<String> spyList = new ArrayList();

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

    /*
     We dont need to instantiate the mock List as the @Mock will create and instantiate the list for us
     */
    @Mock
    private List<String> mockedList;

    /*
    We need to instantiate the list object as the @Spy will use the real objects method if we dont mock them
     */
    @Spy
    private List<String> spyList = new ArrayList();

    @Test
    public void testMockList_checkDefaultBehaviour_whenMethodIsNotMocked() {
        /*If we dont mock the methods of @Mock object and try to call them
        then it will not do anything.*/

        mockedList.add("test"); // add the String into list which will not do anything
        assertNull(mockedList.get(0)); // As the String was not added into the list it will return null value
    }

    @Test
    public void testSpyList_checkDefaultBehaviour_whenMethodIsNotMocked() {
        /* add method is not mocked so the spyList will execute
        * the default behaviour of the add method and it will add a new String into list*/
        spyList.add("test");
        assertEquals("test", spyList.get(0));
    }
}

@Test
public void testMockList_whenMethodIsMocked() {
    /*If we dont mock the methods of @Mock object and try to call them
    then it will not do anything.*/
    when(mockedList.size()).thenReturn(10);
    mockedList.add("One");
    assertNull(mockedList.get(0)); // Again the execution of add and get methods will not have any impact on mocked object

    assertEquals(10, mockedList.size()); // As the String was not added into the list it will return null value
}

@Test
public void testSpyList_whenMethodIsMocked() {
    /* add method is not mocked so the spyList will execute
     * the default behaviour of the add method and it will add a new String into list*/
    when(spyList.size()).thenReturn(10);
    spyList.add("One");
    assertEquals("One", spyList.get(0));

    assertEquals(10, spyList.size()); // size method will return 10 as we have mocked its implementation
}