🚀 Demystifying JUnit Testing with Mockito & Spring Extensions

👋 Before diving deep into testing, I always assumed:

"JUnit is just something you use with @Test… it just works!"

 

But once I actually started exploring test frameworks in real-world projects, I realized there's so much more behind the scenes.

So here’s a blog to clarify the confusion, make it visually digestible, and hopefully save you some debugging hours. Let’s roll! 🧠✨

---

🔍 Step 1: What dependencies should I include for JUnit?

You may have seen these terms in your build.gradle:

testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
implementation 'com.example:some-library:1.2.3'

But wait... what’s the difference? 🤔

✅ implementation

• This means: Include the library for both compile time AND runtime.

• It will be packaged inside the final JAR/WAR.

• Use it for things your production code needs.

🧪 testImplementation

• This means: Use it only during test execution.

• It will NOT be added to the production JAR/WAR.

• Perfect for JUnit, Mockito, and other test libraries.

🎯 Rule of thumb:

If it’s only used in test code, stick with testImplementation.

---

🧩 Step 2: Mockito vs Spring Extension — When to Use What?

You might have seen these annotations:

@ExtendWith(MockitoExtension.class) // JUnit + Mockito

@SpringBootTest                    // Spring Integration Test

Let’s decode them:

🧪 Use @ExtendWith(MockitoExtension.class):

• Ideal for pure unit tests.

• You’re mocking everything and not relying on Spring context.

• Example: Testing service logic with fake repositories.

🧪 Use @SpringBootTest:

• This loads the full Spring context — all your beans!

• Perfect for integration testing.

• You’re testing real method calls, configs, and actual Spring beans.

---

🧠 Step 3: What about @Mock, @InjectMocks, and @MockBean?

Let’s simplify:

Annotation	Comes From	Use Case
@Mock	Mockito	Mock a single class/bean
@InjectMocks	Mockito	Inject mocked dependencies into the real class
@MockBean	Spring	Replace a bean in the Spring context with a mock

🔧 Example:

@Service
public class MyService {
    private final MyRepo repo;

    public MyService(MyRepo repo) { this.repo = repo; }

    public String getData() {
        return repo.fetch();
    }
}

@ExtendWith(MockitoExtension.class)
class MyServiceTest {
    
    @Mock
    MyRepo mockRepo;

    @InjectMocks
    MyService service;

    // Test with mocked repo!
}

🧠 If you're using @SpringBootTest, prefer @MockBean to mock actual Spring beans during integration.

---

💥 Step 4: Why do my integration tests break after adding a config?

Let’s say you added a new config:

@Configuration
public class PubSubConfig {
    @Bean
    public PubSubTemplate pubSubTemplate() {
        return new PubSubTemplate(...); // Requires real credentials
    }
}

Suddenly... 💣 Your tests are failing!

🤯 Why?

Because:

• @SpringBootTest loads the entire Spring context.

• It tries to initialize your new bean.

• If it needs real credentials, BOOM — your test explodes.

🛠 Fix?

@MockBean
private PubSubTemplate pubSubTemplate;

This mocks the bean during testing and avoids loading the real implementation.

📝 Bonus Tip:
Spring test uses application-test.properties. If required values are missing there, config loading can fail too.

---

🧪 Step 5: @ParameterizedTest vs @Test

Annotation	Runs how many times?	Purpose
@Test	Once	For static, fixed tests
@ParameterizedTest	Multiple	Repeats test for each input set

Example:

@ParameterizedTest
@ValueSource(strings = {"Hello", "JUnit"})
void testWithParams(String input) {
    assertNotNull(input);
}

💡 Use @ParameterizedTest when the same logic needs to be tested against multiple inputs!

---

🔚 Wrapping Up

This post hopefully saves you from chasing vague test errors across JUnit, Spring, and Mockito setups.

• Use @MockBean when Spring tries to load a bean you don’t want in tests.

• Use @ExtendWith(MockitoExtension.class) for isolated unit tests.

• Use @SpringBootTest for real context-driven tests — but be mindful of config pitfalls!

• Choose the right annotations for what you’re testing.

🗣 Have you faced crazy test failures or mocking nightmares lately? Share your stories or tricks in the comments — let’s learn together!

Until next time,
– Anand ☕ @ Java Bean Bag