The org.mockito.Mockito class defines a static method mock() to create mock objects. The following code snippet creates mock objects using the mock method:

import org.mockito.Mockito;

public class StockBrokerTest {
  MarketWatcher marketWatcher =
                  Mockito.mock(MarketWatcher.class);
  Portfolio portfolio = 
                  Mockito.mock(Portfolio.class);

}

Instead of directly calling the Mockito.mock() method, we can use the static import feature of Java. The following code snippet simplifies mock creation using static import:

import static org.mockito.Mockito.mock;

public class StockBrokerTest {
  MarketWatcher marketWatcher = mock(MarketWatcher.class);
  Portfolio portfolio = mock(Portfolio.class);
}

The alternative is to annotate the class member variables with the @Mock annotation. The following code snippet uses this annotation:

import org.mockito.Mock;

public class StockBrokerTest {
  @Mock 
  MarketWatcher marketWatcher;
  @Mock 
  Portfolio portfolio;
}

To create mocks using the @Mock annotation, we need to initialize the mocks before test execution, so use MockitoAnnotations.initMocks(this) before using the mocks, or use MockitoJUnitRunner as a JUnit runner.

This example uses MockitoAnnotations:

import static org.junit.Assert.assertEquals;
import org.mockito.MockitoAnnotations;

public class StockBrokerTest {

  @Mock 
  MarketWatcher marketWatcher;

  @Mock 
  Portfolio portfolio;
  
  @Before 
  public void setUp() {
    MockitoAnnotations.initMocks(this);
  }
  

  @Test 
  public void sanity() throws Exception {
    assertNotNull(marketWatcher);
    assertNotNull(portfolio);
  }
}

The following example uses the MockitoJUnitRunner JUnit runner:

import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class StockBrokerTest {

  @Mock
    MarketWatcher marketWatcher;

  @Mock 
    Portfolio portfolio;
  
  @Test   
    public void sanity() throws Exception {
      assertNotNull(marketWatcher);
      assertNotNull(portfolio);
  }
}

Now, to cross-check the information of a final class that Mockito cannot mock, just modify the Portfolio class and make it a final class. Then rerun the test. It will fail because the class is final.

The following screenshot shows the output of the JUnit test run:

Stubbing a method means setting up an expectation on a method invocation or simulating the behavior of the method. Mock objects are basically proxy objects, and they imitate the behavior of real objects. We can stub a method on a mock object to redefine the behavior of the method. In other words, we can return a specific value or throw a specific exception when the method is called on the mocked object. If we don't stub a method of a mock object, the mock object returns the default values such as false for the Boolean return type, null for the object return type, 0 for the integer or long return type, and so on.

Mockito allows stubbing to return a specific value when a specific method is called. The Mockito.when() method identifies a method that needs to be stubbed, and the thenReturn() method returns a specific value.

The when static method is defined in the Mockito class. Here is the process of importing the when method in our test class:

import static org.mockito.Mockito.when;

The following example stubs the getQuote(String symbol) method of MarketWatcher and returns a specific Stock object:

import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class StockBrokerTest {

  @Mock MarketWatcher marketWatcher;
  @Mock Portfolio portfolio;

  @Test
  public void marketWatcher_Returns_current_stock_status() {
    Stock uvsityCorp = new Stock("UV", "Uvsity Corporation",
        new BigDecimal("100.00"));
    
     when(marketWatcher.getQuote(anyString())).
             thenReturn(uvsityCorp);

    assertNotNull(marketWatcher.getQuote("UV"));
  }

The preceding test method creates a stock object and stubs the getQuote method of marketWatcher to return the stock. Note that we passed anyString() to the getQuote method, and anyString represents any string value such as "UV", which we passed in the next line (marketWatcher.getQuote("UV")). Therefore, whenever the getQuote method will be called on the marketWatcher proxy, the stock object will be returned.

The when() method represents the trigger for the time to stub.

The following Mockito methods represent the course of action of the trigger:

The following test code stubs the portfolio and marketWatcher methods:

import com.packt.trading.dto.Stock;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class StockBrokerTest {
  @Mock   MarketWatcher marketWatcher;
 @Mock   Portfolio portfolio;
  StockBroker broker;

  @Before public void setUp() {
   broker = new StockBroker(marketWatcher);
  }

  @Test
  public void when_ten_percent_gain_then_the_stock_is_sold() {
    //Portfolio's getAvgPrice is stubbed to return $10.00
   when(portfolio.getAvgPrice(isA(Stock.class))).
                  thenReturn(new BigDecimal("10.00"));
    //A stock object is created with current price $11.20
    Stock aCorp = new Stock("A", "A Corp", new 
        BigDecimal("11.20"));
   //getQuote method is stubbed to return the stock
    when(marketWatcher.getQuote(anyString())).thenReturn(
        aCorp);
   //perform method is called, as the stock price increases 
  // by 12% the broker should sell the stocks
  broker.perform(portfolio, aCorp);

  //verifying that the broker sold the stocks
  verify(portfolio).sell(aCorp,10);
}

The stubbed getAvgPrice() method returns $10.00, and the stubbed getQuote method returns a stock of A Corp. The stock is configured to return the current stock price as $11.20. As the current stock price ($11.20) is 12 percent more than the average stock price ($10), broker will sell 10 A Corp stocks to book profit.

We already know that the if we don't stub a method on a mock object, then that method returns a default value, but for the void methods, there is nothing to be returned, so no action is taken. In our case, the broker logic invokes the sell method on the portfolio object, but the sell method is a void method, so the sell method is auto-stubbed and it doesn't connect to the database to update the portfolio status. It simply dumps the call.

The perform method is a void method, so it doesn't return any response saying whether it sold some units or not. So how would we check the logic that 10 stocks were sold? We use Mockito.verify.

The verify() method is a static method. It is used to verify the method invocation. If we verify a method call on a mock object but the method is not invoked by the code logic, then the verify() method raises an exception to indicate that there is something wrong in the code logic. In the preceding example we verified that 10 stocks were sold, but if the code logic doesn't call the sell method due to some bug in logic and our test verifies the call in test, it signifies that the code is buggy.

Verifying zero and no more interactions

The verifyZeroInteractions(object... mocks) method takes an array of mock objects and verifies that no methods were called on the mocks. This is important to check the logic branching. Suppose we have two sets of classes, one to send e-mails, and one to generate the mail printout to be sent over the general mail. During code execution, it should either send an e-mail or print a mail. For the e-mail path, we can verify that no methods were called on the mail printout classes.

The following test demonstrates the verifyZeroInteractions method and directly passes the two mock objects to it. Since no methods are invoked on the mock objects, the test passes:

  @Test
  public void verify_zero_interaction() {
    verifyZeroInteractions(marketWatcher,portfolio);
  }

The verifyNoMoreInteractions(Object... mocks) method checks whether any of the given mocks has any unverified interaction. We can use this method after verifying a mock method to ensure that nothing else was invoked in the mock.

The following test code demonstrates the verifyNoMoreInteractions method:

  @Test  public void verify_no_more_interaction() {
   Stock noStock = null;
    portfolio.getAvgPrice(noStock);
    portfolio.sell(null, 0);
    verify(portfolio).getAvgPrice(eq(noStock));
    //this will fail as the sell method was invoked
    verifyNoMoreInteractions(portfolio);
  }

Here is a screenshot showing the JUnit output of the preceding code:

When a piece of code throws a business exception due to violations of some core business logic, then the program should handle the exception instead of halting (for the errors such as Out Of Memory or disk failure, it should definitely halt). In our unit tests, we should consider exceptional conditions such as the code requesting to sell 10 stocks and the portfolio containing only five stocks. Mockito provides methods to throw exceptions during testing.

Mockito defines an action method called thenThrow(Throwable). This method throws a specific exception when a trigger occurs or a stubbed method is called.

The getAvgPrice method scans the database to fetch the average stock price. Suppose the database is unavailable for upgrade or some other reason, and you invoked the method. Then the getAvgPrice will throw an exception, but it is we who should handle the exception and show a proper meaningful error message to the user. We'll use Mockito's API to throw an exception from the getAvgPrice method:

  @Test(expected = IllegalStateException.class)
  public void throwsException() throws Exception {
    when(portfolio.getAvgPrice(isA(Stock.class))).thenThrow(
       new IllegalStateException("Database down"));
    
    portfolio.getAvgPrice(new Stock(null, null, null));
  }

We stubbed the getAvgPrice method of portfolio to throw an exception.

The following is the syntax to throw an exception from a void method:

doThrow(exception).when(mock).voidmethod(arguments);

The buy method portfolio is a void method, so we'll stub it to throw an exception:

  @Test(expected = IllegalStateException.class)
  public void throwsException_void_methods() throws Exception {
    doThrow(new IllegalStateException()).
           when(portfolio).buy(isA(Stock.class));
    portfolio.buy(new Stock(null, null, null));
  }

To learn advanced Mockito topics such as Answers, ArgumentCaptor, matchers, and so on, read the following books: