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.

Practice

1. What is the primary purpose of using @SpringBootTest in a test class?

easy

A. To start the full Spring Boot application context for integration testing

B. To mock all dependencies automatically

C. To run only unit tests without loading Spring context

D. To disable Spring Boot features during testing

Solution

1. Step 1: Understand what @SpringBootTest does

   This annotation loads the entire Spring Boot application context, allowing tests to run with all beans and configurations loaded.

2. Step 2: Compare with other testing approaches

   Unlike unit tests that mock dependencies, @SpringBootTest is used for integration tests to check how components work together.

3. Final Answer:

   To start the full Spring Boot application context for integration testing -> Option A

4. Quick Check:

   @SpringBootTest = full app context [OK]

Hint: Full app context means integration test, not mocking [OK]

Common Mistakes:

• Thinking it mocks dependencies automatically
• Using it for simple unit tests
• Assuming it disables Spring Boot features

2. Which of the following is the correct way to annotate a test class to load the Spring Boot context?

easy

A. @SpringBootApplicationTest

B. @SpringBootTestOnly

C. @TestContextLoader

D. @RunWith(SpringRunner.class) @SpringBootTest

Solution

1. Step 1: Identify the standard annotations for Spring Boot tests

   The correct annotations to load Spring Boot context in JUnit 4 are @RunWith(SpringRunner.class) and @SpringBootTest.

2. Step 2: Check the other options

   Options B, C, and D are not valid Spring Boot or JUnit annotations.

3. Final Answer:

   @RunWith(SpringRunner.class) @SpringBootTest -> Option D

4. Quick Check:

   Use @RunWith(SpringRunner.class) with @SpringBootTest [OK]

Hint: Remember: @RunWith + @SpringBootTest for context loading [OK]

Common Mistakes:

• Using non-existent annotations
• Forgetting @RunWith in JUnit 4
• Confusing with @SpringBootApplication

3. Given the following test class, what will be the output when the test runs successfully?

\@SpringBootTest
class MyServiceTest {
    \@Autowired
    private MyService myService;

    \@Test
    void testService() {
        assertNotNull(myService);
        System.out.println("Service is loaded");
    }
}

medium

A. Test passes and prints 'Service is loaded'

B. Test fails because myService is null

C. Compilation error due to missing annotations

D. Test passes but prints nothing

Solution

1. Step 1: Understand what @SpringBootTest does here

   The annotation loads the full Spring context, so myService bean is injected and not null.

2. Step 2: Analyze the test method

   The assertion assertNotNull(myService) passes, and the print statement outputs "Service is loaded".

3. Final Answer:

   Test passes and prints 'Service is loaded' -> Option A

4. Quick Check:

   Bean injected + assertNotNull = pass and print [OK]

Hint: If context loads, @Autowired bean is not null [OK]

Common Mistakes:

• Assuming myService is null without context
• Forgetting that @SpringBootTest loads beans
• Confusing compilation errors with runtime behavior

4. You have a test annotated with @SpringBootTest but it fails with a NoSuchBeanDefinitionException. What is the most likely cause?

medium

A. The test method is private

B. The test class is missing @Test annotation

C. The bean is not defined or scanned in the application context

D. The Spring Boot version is outdated

Solution

1. Step 1: Understand the exception meaning

   NoSuchBeanDefinitionException means Spring could not find a bean of the required type in the context.

2. Step 2: Identify common reasons for missing beans

   This usually happens if the bean is not defined, not annotated with @Component/@Service, or not in a scanned package.

3. Final Answer:

   The bean is not defined or scanned in the application context -> Option C

4. Quick Check:

   Missing bean definition = NoSuchBeanDefinitionException [OK]

Hint: Missing bean means not defined or scanned [OK]

Common Mistakes:

• Blaming test method visibility
• Assuming missing @Test causes bean errors
• Thinking Spring Boot version causes missing bean

5. You want to speed up your test suite by loading only a part of the Spring Boot context. Which approach can you use with @SpringBootTest to limit the loaded beans?

hard

A. Remove @SpringBootTest and use plain JUnit tests

B. Use @SpringBootTest(classes = YourConfig.class) to load only specific configuration

C. Add @MockBean to all beans manually

D. Use @SpringBootTest with @Transactional only

Solution

1. Step 1: Understand how to limit context loading

   By specifying classes attribute in @SpringBootTest, you can load only selected configuration classes, reducing context size.

2. Step 2: Evaluate other options

   Removing @SpringBootTest disables context loading, @MockBean mocks beans but does not limit context size, and @Transactional controls transactions, not context loading.

3. Final Answer:

   Use @SpringBootTest(classes = YourConfig.class) to load only specific configuration -> Option B

4. Quick Check:

   Limit context by specifying classes in @SpringBootTest [OK]

Hint: Specify classes attribute to limit context [OK]

Common Mistakes:

• Thinking @MockBean reduces context size
• Removing @SpringBootTest disables context, not limits
• Confusing @Transactional with context loading