Example code for Mockito's mock() method

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import java.util.List;
import org.junit.jupiter.api.Test;

public class MockitoMockExample {

    @SuppressWarnings("unchecked")
    @Test
    public void testMockWithList() {
        // Create mock object of List interface
        List mockList = mock(List.class);

        // Stubbing: Define behavior of size() method to return 5
        when(mockList.size()).thenReturn(5);

        // Assertion to verify the stubbed behavior
        assertTrue(mockList.size() == 5);

        // By default, other methods return default values (null, 0, false)
        assertNull(mockList.get(0));
    }
}

Another example showing a more practical use case with mocking a class with dependencies:

java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class EmailService {
    public void sendEmail(String recipient, String message) {
        // Some complex email sending logic
    }
}

class InvoiceStorage {
    public boolean hasOutstandingInvoice(String customerId) {
        // Connects to external system to check invoice
        return true;
    }
}

class LateInvoiceNotifier {
    private final EmailService emailService;
    private final InvoiceStorage invoiceStorage;

    public LateInvoiceNotifier(EmailService emailService, InvoiceStorage invoiceStorage) {
        this.emailService = emailService;
        this.invoiceStorage = invoiceStorage;
    }

    public void notifyIfLate(String customerId) {
        if (invoiceStorage.hasOutstandingInvoice(customerId)) {
            emailService.sendEmail(customerId, "Your invoice is overdue.");
        }
    }
}

public class LateInvoiceNotifierTest {

    @Test
    public void testNotifyIfLate() {
        // Mock dependencies
        EmailService emailServiceMock = mock(EmailService.class);
        InvoiceStorage invoiceStorageMock = mock(InvoiceStorage.class);

        // Stub method hasOutstandingInvoice to return true
        when(invoiceStorageMock.hasOutstandingInvoice("customer123")).thenReturn(true);

        LateInvoiceNotifier notifier = new LateInvoiceNotifier(emailServiceMock, invoiceStorageMock);
        notifier.notifyIfLate("customer123");

        // Verify that email was sent
        verify(emailServiceMock).sendEmail("customer123", "Your invoice is overdue.");
    }
}

Example showing partial mocks with Mockito `spy()` method and `mock()`:

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class MockitoSpyExample {

    class Calculator {
        public int add(int a, int b) {
            return a + b;
        }

        public int multiply(int a, int b) {
            return a * b;
        }
    }

    @Test
    public void testPartialMockWithSpy() {
        Calculator calculator = new Calculator();
        Calculator spyCalculator = spy(calculator);

        // Stub multiply method
        when(spyCalculator.multiply(2, 3)).thenReturn(10);

        // multiply is stubbed
        assertEquals(10, spyCalculator.multiply(2, 3));

        // add uses real implementation
        assertEquals(5, spyCalculator.add(2, 3));
    }

    @Test
    public void testMockWithSomeRealMethods() {
        Calculator calculatorMock = mock(Calculator.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));

        // Stub add method only
        when(calculatorMock.add(1, 1)).thenReturn(5);

        assertEquals(5, calculatorMock.add(1, 1)); // stubbed
        assertEquals(6, calculatorMock.multiply(2, 3)); // real method called
    }
}

Example demonstrating deep stubs to mock nested method calls easily:

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

interface Repository {
    String fetchData();
}

interface Service {
    Repository getRepository();
}

public class DeepStubTest {

    @Test
    public void testDeepStub() {
        Service serviceMock = mock(Service.class, RETURNS_DEEP_STUBS);

        when(serviceMock.getRepository().fetchData()).thenReturn("Mocked Data");

        String data = serviceMock.getRepository().fetchData();

        assertEquals("Mocked Data", data);
    }
}

Example of using `mock()` for a void method and verifying interactions:

java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class PrinterService {
    public void printInvoice(String invoice) {
        // print invoice
    }
}

class EmailService {
    public void sendInvoice(String invoice, String email) {
        // send invoice via email
    }
}

class FinalInvoiceStep {
    private PrinterService printerService;
    private EmailService emailService;

    public FinalInvoiceStep(PrinterService printerService, EmailService emailService) {
        this.printerService = printerService;
        this.emailService = emailService;
    }

    public void handleInvoice(String invoice, boolean wantsEmail, String email) {
        if (wantsEmail) {
            emailService.sendInvoice(invoice, email);
        } else {
            printerService.printInvoice(invoice);
        }
    }
}

public class FinalInvoiceStepTest {

    @Test
    public void testEmailInvoiceSent() {
        PrinterService printerServiceMock = mock(PrinterService.class);
        EmailService emailServiceMock = mock(EmailService.class);

        FinalInvoiceStep finalInvoiceStep = new FinalInvoiceStep(printerServiceMock, emailServiceMock);

        finalInvoiceStep.handleInvoice("invoice123", true, "
 <script language='JavaScript' type='text/javascript'>
 <!--
 var prefix = 'm&#97;&#105;lt&#111;:';
 var suffix = '';
 var attribs = '';
 var path = 'hr' + 'ef' + '=';
 var addy71777 = 'c&#117;st&#111;m&#101;r' + '&#64;';
 addy71777 = addy71777 + '&#101;x&#97;mpl&#101;' + '&#46;' + 'c&#111;m';
 document.write( '<a ' + path + '\'' + prefix + addy71777 + suffix + '\'' + attribs + '>' );
 document.write( addy71777 );
 document.write( '<\/a>' );
 //-->
 </script><script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '<span style=\'display: none;\'>' );
 //-->
 </script>This e-mail address is being protected from spambots. You need JavaScript enabled to view it
 <script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '</' );
 document.write( 'span>' );
 //-->
 </script>");

        verify(emailServiceMock).sendInvoice("invoice123", "
 <script language='JavaScript' type='text/javascript'>
 <!--
 var prefix = 'm&#97;&#105;lt&#111;:';
 var suffix = '';
 var attribs = '';
 var path = 'hr' + 'ef' + '=';
 var addy675 = 'c&#117;st&#111;m&#101;r' + '&#64;';
 addy675 = addy675 + '&#101;x&#97;mpl&#101;' + '&#46;' + 'c&#111;m';
 document.write( '<a ' + path + '\'' + prefix + addy675 + suffix + '\'' + attribs + '>' );
 document.write( addy675 );
 document.write( '<\/a>' );
 //-->
 </script><script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '<span style=\'display: none;\'>' );
 //-->
 </script>This e-mail address is being protected from spambots. You need JavaScript enabled to view it
 <script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '</' );
 document.write( 'span>' );
 //-->
 </script>");
        verifyNoInteractions(printerServiceMock);
    }

    @Test
    public void testPrintedInvoiceSent() {
        PrinterService printerServiceMock = mock(PrinterService.class);
        EmailService emailServiceMock = mock(EmailService.class);

        FinalInvoiceStep finalInvoiceStep = new FinalInvoiceStep(printerServiceMock, emailServiceMock);

        finalInvoiceStep.handleInvoice("invoice123", false, "
 <script language='JavaScript' type='text/javascript'>
 <!--
 var prefix = 'm&#97;&#105;lt&#111;:';
 var suffix = '';
 var attribs = '';
 var path = 'hr' + 'ef' + '=';
 var addy74988 = 'c&#117;st&#111;m&#101;r' + '&#64;';
 addy74988 = addy74988 + '&#101;x&#97;mpl&#101;' + '&#46;' + 'c&#111;m';
 document.write( '<a ' + path + '\'' + prefix + addy74988 + suffix + '\'' + attribs + '>' );
 document.write( addy74988 );
 document.write( '<\/a>' );
 //-->
 </script><script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '<span style=\'display: none;\'>' );
 //-->
 </script>This e-mail address is being protected from spambots. You need JavaScript enabled to view it
 <script language='JavaScript' type='text/javascript'>
 <!--
 document.write( '</' );
 document.write( 'span>' );
 //-->
 </script>");

        verify(printerServiceMock).printInvoice("invoice123");
        verifyNoInteractions(emailServiceMock);
    }
}

Using `mock()` to mock methods with custom answers depending on arguments:

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.mockito.stubbing.Answer;

import java.util.ArrayList;
import java.util.List;

public class CustomAnswerTest {

    @Test
    public void testCustomAnswer() {
        List mockedList = mock(List.class);

        when(mockedList.get(anyInt())).thenAnswer((Answer) invocation -> {
            Integer index = invocation.getArgument(0);
            return "Element " + index;
        });

        assertEquals("Element 0", mockedList.get(0));
        assertEquals("Element 5", mockedList.get(5));
    }
}

Example of mocking a class with annotation-based approach:

java
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

public class MockitoAnnotationTest {

    @Mock
    List mockedList;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testMockList() {
        when(mockedList.size()).thenReturn(10);

        assertEquals(10, mockedList.size());
        verify(mockedList).size();
    }
}

Example showing that by default `mock()` returns default values for unstubbed methods:

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.util.List;

public class DefaultAnswerTest {

    @Test
    public void testDefaultReturnValues() {
        List mockedList = mock(List.class);

        // size() not stubbed, returns 0 by default
        assertEquals(0, mockedList.size());

        // get() not stubbed, returns null
        assertNull(mockedList.get(0));
    }
}

Example of using `mock()` along with verification to check method calls:

java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

public class VerifyExample {

    interface CalculatorService {
        int add(int a, int b);
    }

    static class Calculator {
        private CalculatorService service;
        public Calculator(CalculatorService service) {
            this.service = service;
        }
        public int performAdd(int a, int b) {
            return service.add(a, b);
        }
    }

    @Test
    public void testVerifyAddMethodCalled() {
        CalculatorService serviceMock = mock(CalculatorService.class);

        when(serviceMock.add(2, 3)).thenReturn(5);

        Calculator calculator = new Calculator(serviceMock);
        int result = calculator.performAdd(2, 3);

        verify(serviceMock).add(2, 3);
        assertEquals(5, result);
    }
}

Example of partial mocking a real object with `mock()` using `CALLS_REAL_METHODS`:

java
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class PartialMockTest {

    class Stock {
        private double price;
        private int quantity;

        public Stock(double price, int quantity) {
            this.price = price;
            this.quantity = quantity;
        }

        public double getPrice() {
            return price;
        }

        public int getQuantity() {
            return quantity;
        }

        public double getValue() {
            return getPrice() * getQuantity();
        }
    }

    @Test
    public void testPartialMock() {
        Stock stockMock = mock(Stock.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));

        when(stockMock.getPrice()).thenReturn(100.0);
        when(stockMock.getQuantity()).thenReturn(200);

        double value = stockMock.getValue();

        assertEquals(20000, value, 0.001);
    }
}

This series of examples covers the main practical usages of Mockito's `mock()` method in unit testing: creating mocks, stubbing method calls, verifying interactions, handling void methods, partial mocks, deep stubbing, and annotations for mocks initialization. The examples also illustrate custom answers, default values, and integration with JUnit tests. This demonstrates how `mock()` is fundamental in isolating components by replacing dependencies with controlled mock instances.