Spring Boot @SpringBootTest in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the test execution result of this Spring Boot test?

Consider this Spring Boot test class annotated with @SpringBootTest. What will be the test result when running this test?

JUnit

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertTrue;

@SpringBootTest
public class SampleTest {

    @Test
    void contextLoads() {
        assertTrue(true);
    }
}

A Test fails with ApplicationContextException due to missing configuration.

B Test fails with AssertionError.

C Test passes successfully.

D Test is skipped because no @RunWith annotation is present.

💡 Hint

Remember that @SpringBootTest loads the full application context and the assertion is true.

The test annotated with @SpringBootTest loads the full Spring application context. The assertion assertTrue(true) always passes, so the test will pass successfully.

Option C is incorrect because the assertion is true. Option C is incorrect because no configuration is missing. Option C is incorrect because @SpringBootTest with JUnit 5 does not require @RunWith.

❓ assertion

intermediate

Which assertion correctly verifies a bean is loaded in @SpringBootTest?

Given a Spring Boot test annotated with @SpringBootTest, which assertion correctly checks that a bean of type MyService is loaded in the application context?

JUnit

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class BeanLoadTest {

    @Autowired
    private MyService myService;

    @Test
    void testBeanLoaded() {
        // Which assertion is correct here?
    }
}

A assertNotNull(myService);

B assertFalse(myService != null);

C assertTrue(myService == null);

D assertEquals(null, myService);

💡 Hint

If the bean is loaded, the injected field should not be null.

When a bean is loaded and injected by Spring, the field is not null. So assertNotNull(myService) correctly verifies the bean is present.

Options A, C, and D incorrectly assert the bean is null or not present.

🔧 Debug

advanced

Why does this @SpringBootTest test fail with ApplicationContextException?

This test fails with ApplicationContextException when run. What is the most likely cause?

JUnit

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

@SpringBootTest(classes = NonExistentConfig.class)
public class FailingTest {

    @Test
    void testSomething() {
        // test logic
    }
}

A The specified configuration class NonExistentConfig does not exist, causing context load failure.

B The test method is missing @Test annotation.

C The @SpringBootTest annotation is missing required properties.

D The test class must extend a Spring Boot base test class.

💡 Hint

Check the classes attribute in @SpringBootTest.

The test specifies a configuration class NonExistentConfig that does not exist. This causes Spring Boot to fail loading the application context, resulting in ApplicationContextException.

Option A is incorrect because the test method has @Test. Option A is incorrect because @SpringBootTest does not require additional properties. Option A is incorrect because extending a base class is not required.

❓ framework

advanced

Which annotation combination is best to load only a slice of the Spring context for a web layer test?

You want to test only the web layer (controllers) without loading the full Spring Boot context. Which annotation combination achieves this?

A @SpringBootTest + @AutoConfigureMockMvc

B @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)

C @DataJpaTest

D @WebMvcTest

💡 Hint

Look for the annotation designed for slicing web layer tests.

@WebMvcTest loads only the web layer components such as controllers and related configurations, making tests faster and more focused.

Option D loads the full context and configures MockMvc. Option D is for JPA layer tests. Option D disables web environment but still loads full context.

🧠 Conceptual

expert

What is the effect of using @SpringBootTest with webEnvironment = WebEnvironment.RANDOM_PORT?

Select the correct statement about @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT):

A Starts the server on the default port 8080 regardless of the setting.

B Starts the embedded server on a random port and allows injecting the port number for real HTTP tests.

C Disables the embedded server and mocks all HTTP requests internally.

D Runs the test without loading the Spring context.

💡 Hint

Think about how to test real HTTP endpoints with a random port.

Using webEnvironment = WebEnvironment.RANDOM_PORT starts the embedded server on a random free port. This allows tests to perform real HTTP calls without port conflicts. The port can be injected using @LocalServerPort.

Option B is incorrect because the server is started, not mocked. Option B is incorrect because the port is random, not fixed. Option B is incorrect because the Spring context is loaded.