Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

Mocking protected method in Java is similar to mocking a public one, with one caveat: visibility of this method in the test class. We have visibility of protected methods of class A from the same package classes and ones that extend A. So, if we try to test class A from a different package, we’ll face issues.

In this tutorial, we’ll approach the case of mocking protected method of the class under test. We’ll demonstrate both cases of having access to the method and not. We’ll do that by using Mockito spies instead of mocks since we want to stub just some behavior of the under-test class.

2. Mocking protected Method

Mocking protected method with Mockito is straightforward when we have access to it. We can get access in two ways. First, we change the scope of protected to public, or second, we move the test class into the same package as the class with the protected method.

But this isn’t an option sometimes, and so an alternative is to follow indirect practices. The most common ones, without using any external libraries, are:

  • to use JUnit5 and Reflection
  • to use an inner test class that extends the class under test

If we try to change the access modifier, this might lead to unwanted behavior. Using the most restrictive access level is good practice unless there is a good reason not to. Similarly, if it makes sense to change the location of the test, then moving it to the same package as the class with the protected method is an easy option.

If neither of these options works for our case, JUnit5 with Reflection is a good call, when there is only one protected method to stub in the class. For a class A with more than one protected method that we need to stub, creating an inner class that extends A is the cleaner solution.

3. Mocking Visible protected Method

In this section, we’ll handle the cases in which the test has access to the protected method, or we can make changes to get access. As mentioned before, the changes could be making the access modifier public or moving the test to the same package as the class with the protected method.

Let’s see the Movies class as an example, which has a protected method getTitle() to retrieve the value of private field title. It also contains a public method getPlaceHolder(), which is available to clients:

public class Movies {
    private final String title;

    public Movies(String title) {
        this.title = title;
    }

    public String getPlaceHolder() {
        return "Movie: " + getTitle();
    }

    protected String getTitle() {
        return title;
    }
}

In the test class, first, we assert that the initial value of the getPlaceholder() method is the one we expect. Then we stub the functionality of the protected method using Mockito spies and we assert that the new value getPlaceholder() returns contains the stubbed value of getTitle():

@Test
void givenProtectedMethod_whenMethodIsVisibleAndUseMockitoToStub_thenResponseIsStubbed() {
    Movies matrix = Mockito.spy(new Movies("The Matrix"));
    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: The Matrix");

    doReturn("something else").when(matrix).getTitle();

    assertThat(matrix.getTitle()).isEqualTo("something else");
    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: something else");
}

4. Mocking Non-Visible protected Method

Next, let’s see how mocking a protected method with Mockito is done when we don’t have access to it. The use case we’ll deal with is when the test class is in a different package than the class we want to stub. In such case, we have two options:

  • JUnit5 with Reflection
  • inner class which extends the class with the protected method

4.1. Using JUnit and Reflection

JUnit5 provides a class, ReflectionSupport, that handles common reflection cases for testing, like finding/invoking methods, etc. Let’s see how this works with our previous code:

@Test
void givenProtectedMethod_whenMethodIsVisibleAndUseMockitoToStub_thenResponseIsStubbed() throws NoSuchMethodException {
    Movies matrix = Mockito.spy(new Movies("The Matrix"));
    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: The Matrix");

    ReflectionSupport.invokeMethod(
            Movies.class.getDeclaredMethod("getTitle"),
            doReturn("something else").when(matrix));

    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: something else");
}

Here, we use the invokeMethod() of ReflectionSupport that sets the value of the protected method to be the stubbed Movie object, when invoked.

4.2. Using Inner Class

We can overcome the visibility issue by creating an inner class that extends the class under test and makes the protected method visible. The inner class can be a class on its own if we need to mock the same class’s protected method in different test classes.

In our case, it makes sense to have the MoviesWrapper class that extends Movies, from our previous code, as an inner class of the test class:

private static class MoviesWrapper extends Movies {
    public MoviesWrapper(String title) {
        super(title);
    }

    @Override
    protected String getTitle() {
        return super.getTitle();
    }
}

This way, we get access to getTitle() of Movies through the MoviesWrapper class. If, instead of an inner class we use a standalone one, the method access modifier might need to become public.

The test then uses the MoviesWrapper class as the class under test. This way we have access to getTitle() and can easily stub it using Mockito spies:

@Test
void givenProtectedMethod_whenMethodNotVisibleAndUseInnerTestClass_thenResponseIsStubbed() {
    MoviesWrapper matrix = Mockito.spy(new MoviesWrapper("The Matrix"));
    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: The Matrix");

    doReturn("something else").when(matrix).getTitle();

    assertThat(matrix.getPlaceHolder()).isEqualTo("Movie: something else");
}

5. Conclusion

In this article, we discussed the difficulties with visibility when mocking protected methods in Java and demonstrated the possible solutions. There are different options for each use case we might face and based on the examples, we should be able to pick the right one each time.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW