Home » Core Java » PowerMockito » PowerMock Mock Static Method Example

About Julen Pardo

Julen Pardo
Julen holds his Bachelor's Degree in Computer Engineering from Mondragon Unibertsitatea, in Spain. Currently he is working in Munich, Germany, as Software Engineer. He contributes to open source projects with plugins, and he also develops his own, open-source projects. Julen is continuously trying to learn and adopt Software Engineering principles and practices to build better, more secure, readable and maintainable software.

PowerMock Mock Static Method Example

In the Mockito Tutorial for Beginners, we did a general introduction to the Mockito mocking framework for JUnit tests. One the things that we did not see, was the mocking of static methods. That is because Mockito doesn’t allow to do that.

To solve this, we will use PowerMock, a framework that extends Mockito’s functionalities (and other mocking frameworks’ also), which allows, among other things, static method mocking.

For this example, we will use:

  • Java 1.7.0
  • Eclipse Mars 2, release 4.5.2.
  • JUnit 4.
  • PowerMock 1.6.5 for Mockito, and its dependencies.
You may skip project creation and jump directly to the beginning of the example below.

1. Project creation

Go to “File/New/Java Project”. You will be asked to enter a name for the project. Then, press “Next”, not “Finish”.

In the new window that has appeared, go to “Libraries” tab, select “Add library” button, and then select “JUnit”, as shown in the following images below:

1. Adding libraries to the project

2. Adding JUnit as library

With this, we have added the required dependencies for JUnit testing. You can now finish the project creation.

Now, right click the folder icon in the Package Explorer, and select “New/Source Folder”, and enter the name you want to give to the test folder.

3.Creating folder for tests

1.1. Powermock installation

Apart from JUnit and its dependencies, we need several more libraries.

4. Adding PowerMock and dependencies to build path

2. Base code

Let’s suppose that we have to develop a class for making a query against a database. We could do something similar to the following:


package com.javacodegeeks.powermock.staticmethod;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DatabaseReader {

    public static final String CONNECTION = "jdbc:mysql://localhost/testdb";
    public static String getById(int id) throws SQLException {
        String query = "SELECT * FROM Foo WHERE Id = ?";
        Connection connection = DriverManager.getConnection(CONNECTION);
        PreparedStatement preparedStatement = connection.prepareStatement(query);
        preparedStatement.setInt(1, id);
        ResultSet resultSet = preparedStatement.executeQuery();
        String result = resultSet.getString(0);
        return result;

We won’t need a real database (remember that we are mocking).

3. Mocking the method

This is how we would mock our getById static method, using PowerMock:

package com.javacodegeeks.powermock.staticmethod;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.verifyStatic;

import java.sql.SQLException;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

public class DatabaseReaderTest {

    public void testGetById() {
        int inputId = 1;
        String returnValue = "JavaCodeGeeks";


        try {

            String actual = DatabaseReader.getById(inputId);
            assertEquals(returnValue, actual);
        } catch (SQLException e) {
            fail("No exception should be thrown.");

Which is the main difference with “normal” mocking? Is that we are specifying that a class’ static function will be mocked, instead of creating a mock instance and adding behavior to a function. That is done with mockStatic() method and @PrepareForTest annotation, and, then, the behavior is defined as always with when(), but accessing the method statically. Note that we also need to run the test case with @RunWith(PowerMockRunner.class) annotation, and also that we can make the verification of the static method call with verifyStatic().

Take into account that the following test would work:


public void testGetById() {
    int inputId = 1;
    String returnValue = "JavaCodeGeeks";
    DatabaseReader databaseReaderMock = Mockito.mock(DatabaseReader.class);
    try {
        String actual = DatabaseReader.getById(inputId);
        assertEquals(returnValue, actual);
    } catch (SQLException e) {
        fail("No exception should be thrown.");

// ...

Without the need of PowerMock or any other special mocking technique for the method. But it would not make any sense to test a static method as a object method, since it’s supposed to be called as a class method, so the test would not reflect a real case.

3.1. Mocking the database connection

We can go further and mock what happens inside getById() method, inside of just adding a predefined behavior to it. For that, we would have to mock the database connection, done with DriverManager.getConnection() method. With Mockito, we couldn’t mock the method in that way. But, as we have seen with PowerMock, we can mock it as any other method.


// ...

public void testGetByIdMockDatabase() {
    String query = "SELECT * FROM Foo WHERE Id = ?";
    int inputId = 1;
    String returnValue = "JavaCodeGeeks";
    Connection connectionMock = Mockito.mock(Connection.class);
    PreparedStatement preparedStatementMock = Mockito.mock(PreparedStatement.class);
    ResultSet resultSetMock = Mockito.mock(ResultSet.class);
    try {


        String actual = DatabaseReader.getById(inputId);

        assertEquals(returnValue, actual);
    } catch (SQLException e) {
        fail("No exception should be thrown.");

// ...

As you can see, apart from mocking the DriverManager.getConnection() static method, we have to create the mocks of the other objects used to make the query, combining PowerMock’s static mocking, and Mockito’s default features; but the concept is the same: mocking functions that “belong” to class, and not necessarily to its instances. Without PowerMock, there would not be way to test getById() method with mocks, and a real database would be required.

4. Summary

This tutorial has shown how to mock static methods with PowerMock, a feature that is not available in the Mockito framework. We have seen that is specially useful when a method depends on a static method of another class.

5. Download the Eclipse Project

This was an example of mocking static methods with PowerMock.

You can download the full source code of this example here: PowerMockMockStaticMethod
0 0 vote
Article Rating

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!


1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design


and many more ....


Receive Java & Developer job alerts in your Area


Notify of
The comment form collects your name, email and content to allow us keep track of the comments placed on the website. Please read and accept our website Terms and Privacy Policy to post a comment.

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x