Disabling ApplicationRunner and CommandLineRunner Beans During JUnit Testing in Spring Boot

In Spring Boot, ApplicationRunner and CommandLineRunner beans are often used to perform specific tasks at application startup, such as initializing data or writing configuration information. In unit testing, especially in JUnit testing we want to prevent these beans from running, since that it can interfere with the test environment or produce undesirable outcome behavior.

This article explains how to prevent these runner beans from executing during tests that ensures cleaner and more controlled test execution.

Prerequisites:

• Basic knowledge of Java and Spring Boot.
• Basic understanding of JUnit testing.
• Maven for dependency management.
• JDK and IntelliJ IDEA installed.

Disabling Runners During Tests

When writing tests for a Spring Boot application, we may not want certain startup logic (like the logic provided by ApplicationRunner or CommandLineRunner) to execute. This can be managed using the following techniquesthat are,

1. Profile-Based Approach: Use Spring profiles to conditionally enable or disable the runner beans.
2. Conditional Beans: Use conditional annotations to prevent the execution of these beans during tests.

Profile-Based Approach

In this method, we can define ApplicationRunner or CommandLineRunner beans to be active only under specific profiles (e.g., dev, prod). When running tests, we can exclude these profiles to prevent the runners from executing.

Step 1: Define the CommandLineRunner Bean with a Profile

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

@Component
@Profile("!test") // Exclude the 'test' profile
public class StartupRunner implements CommandLineRunner {
 @Override
 public void run(String... args) throws Exception {
 System.out.println("CommandLineRunner logic executing during startup...");
 }
}

In the above code, the @Profile("!test") annotation ensures that the runner will not execute when the test profile is active.

Step 2: Set the Active Profile in the Test

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("test") // Activate the 'test' profile
public class MyServiceTest {

 @Test
 public void testServiceMethod() {
 // Your test logic here
 }
}

By using the @Activeprofiles("test"), we ensure that the StartupRunner beans does not run during the test.

Using Conditional Beans

Another approach is to conditionally create the CommandLineRunner bean based on whether the application is running in a test environment.

Step 1: Create a Conditional Bean

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class RunnerConfig {

 @Bean
 @Profile("!test") // Exclude the 'test' profile
 public CommandLineRunner startupRunner() {
 return args -> {
 System.out.println("CommandLineRunner logic executing during startup...");
 };
 }
}

In this configuration, the runner bean can be created only when the test profile is not active.

Step 2: Activate the test Profile in the JUnit Test

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("test")
public class RunnerTest {

 @Test
 public void contextLoads() {
 // Test logic without the CommandLineRunner bean executing
 }
}

This method ensures that the startupRunner bean is not created during testing, preventing it from executing.

Project Implementation to Prevent ApplicationRunner or CommandLineRunner Beans

Here is a complete example that demonstrates how to prevent the ApplicationRunner or CommandLineRunner beans from executing during JUnit tests.

Step 1: Create a Spring Boot Project

Create a new Spring Boot project using IntelliJ IDEA.

Choose the following options:

• Name: example-runner-project
• Language: Java
• Type: Maven
• Packaging: Jar

Click on the Next button.

Step 2: Add the Dependencies

Add the following dependencies into the project:

• Spring Web
• Spring Boot DevTools
• Lombok

Click on the Create button.

Project Structure

Once project creation done, set the folder structure as shown in the below image:

Step 3: Configure Application Properties

Add the following to the application.properties:

spring.application.name=example-runner-project
server.port=8080

Step 4: Create the RunnerConfig Class

Step 5: Create the StartupRunner Class

Step 6: Main Class

Step 7: Create the MockRunnerTest Class

Step 8: MainTest Class

pom.xml File

Step 9: Run the Application

Once you complete the project, we can run it and check the startup output:

Step 10: Running the Tests

We can run the test suite using the below Maven command:

mvn test

Output:

This example project demonstrates how to prevent the CommandLineRunner or ApplicationRunner beans from executing during JUnit testing. By using profile, we can control the activation of the running beans, ensuring they do not interface with test logic.