@SpringBootTest for integration tests - Step-by-Step Execution

Concept Flow - @SpringBootTest for integration tests

Start Test Class

↓

@SpringBootTest Annotation

↓

Load Full Application Context

↓

Inject Beans & Dependencies

↓

Run Test Methods

↓

Verify Behavior & State

↓

Test Complete

The test class marked with @SpringBootTest loads the full app context, injects beans, runs tests, then verifies results.

Execution Sample

Spring Boot

@SpringBootTest
class MyServiceIntegrationTest {
  @Autowired
  MyService service;

  @Test
  void testService() {
    assertEquals("Hello", service.greet());
  }
}

This test loads the full Spring context, injects MyService, and checks its greet() method returns "Hello".

Execution Table

Step	Action	Evaluation	Result
1	Start test class with @SpringBootTest	Annotation triggers full context load	Application context starts
2	Inject MyService bean	Spring finds MyService in context	MyService instance injected
3	Run testService() method	Call service.greet()	Returns "Hello"
4	Assert returned value	Check if equals "Hello"	Assertion passes
5	Test completes	No errors thrown	Test success

💡 Test completes successfully after assertion passes and no exceptions occur

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
service	null	MyService instance	MyService instance	MyService instance
greetResult	undefined	undefined	"Hello"	"Hello"

Key Moments - 3 Insights

Why does the test load the full application context instead of just one bean?

Because @SpringBootTest tells Spring to load the entire app context, not just a slice. This is shown in execution_table step 1 where the full context starts.

How does Spring know which bean to inject into the test?

Spring scans the context for a matching bean type and injects it. In execution_table step 2, MyService is found and injected automatically.

What happens if the assertion fails?

The test would throw an error and fail. Here in execution_table step 4, the assertion passes, so no failure occurs.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of 'service' after step 2?

A MyService instance

B null

C undefined

D String value

💡 Hint

Check variable_tracker row for 'service' after step 2

At which step does the test verify the output of the greet() method?

A Step 3

B Step 4

C Step 1

D Step 5

💡 Hint

Look at execution_table where assertion is checked

If @SpringBootTest was removed, how would the execution change?

A Full context would still load

B No beans would be injected automatically

C Test would run faster but fail to inject beans

D Test would pass without context

💡 Hint

Think about what @SpringBootTest controls in execution_table step 1 and 2

Concept Snapshot

@SpringBootTest annotation loads full Spring application context for integration tests.
It injects all beans like in a running app.
Use @Autowired to get beans in test class.
Run test methods to verify real behavior.
Good for testing multiple components working together.
Slower than slice tests but more complete.

Full Transcript

The @SpringBootTest annotation tells Spring to load the entire application context when running tests. This means all beans and configurations are loaded as if the app is running normally. In the test class, Spring injects the needed beans automatically, like MyService in the example. The test method calls a service method and asserts the expected result. If the assertion passes and no errors occur, the test succeeds. This approach tests the integration of components together, not just isolated units. It is slower but ensures the app works as a whole.

Practice

1. What is the main purpose of using @SpringBootTest in a Spring Boot project?

easy

A. To configure database connections only

B. To mock all dependencies automatically

C. To run unit tests without loading Spring context

D. To load the full application context for integration 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 annotations

   Unlike unit tests or mocks, @SpringBootTest is used for integration tests that need the full app context.

3. Final Answer:

   To load the full application context for integration testing -> Option D

4. Quick Check:

   @SpringBootTest = full app context load [OK]

Hint: Remember: @SpringBootTest loads full app context for integration [OK]

Common Mistakes:

• Thinking it mocks all dependencies automatically
• Confusing it with unit test annotations
• Assuming it only configures database connections

2. Which of the following is the correct way to use @SpringBootTest to start the web environment on a random port?

easy

A. @SpringBootTest(webEnv = RANDOM_PORT)

B. @SpringBootTest(webEnvironment = "random")

C. @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)

D. @SpringBootTest(port = RANDOM_PORT)

Solution

1. Step 1: Recall the correct attribute name and value

   The attribute to set the web environment is webEnvironment, and the enum value for random port is WebEnvironment.RANDOM_PORT.

2. Step 2: Check syntax correctness

   @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) uses the correct attribute and enum syntax. Other options use incorrect attribute names or string values.

3. Final Answer:

   @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) -> Option C

4. Quick Check:

   Correct attribute and enum = @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) [OK]

Hint: Use webEnvironment = WebEnvironment.RANDOM_PORT exactly [OK]

Common Mistakes:

• Using wrong attribute name like webEnv
• Passing string instead of enum
• Trying to set port directly in annotation

3. Given the following test class snippet, what will be the output when running the test?

\@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyIntegrationTest {
  \@Autowired
  private TestRestTemplate restTemplate;

  \@Test
  void testHelloEndpoint() {
    String response = restTemplate.getForObject("/hello", String.class);
    System.out.println(response);
  }
}

Assuming the /hello endpoint returns "Hello, Spring!".

medium

A. Hello, Spring!

B. null

C. 404 Not Found error

D. Test fails with context load error

Solution

1. Step 1: Understand the test setup

   The test uses @SpringBootTest with RANDOM_PORT and injects TestRestTemplate, which allows calling the real HTTP endpoint.

2. Step 2: Predict the endpoint call result

   The /hello endpoint returns "Hello, Spring!" so the call will return this string and print it.

3. Final Answer:

   Hello, Spring! -> Option A

4. Quick Check:

   TestRestTemplate calls real endpoint = "Hello, Spring!" [OK]

Hint: TestRestTemplate calls real endpoint in @SpringBootTest [OK]

Common Mistakes:

• Expecting null because of missing mocks
• Assuming 404 because of wrong port
• Thinking context fails to load

4. You wrote this test but it fails with a NoSuchBeanDefinitionException for TestRestTemplate. What is the likely cause?

\@SpringBootTest
class MyTest {
  \@Autowired
  private TestRestTemplate restTemplate;

  \@Test
  void test() {
    // test code
  }
}

medium

A. TestRestTemplate is not a Spring bean

B. Missing webEnvironment setting to start web server

C. Forgot to add @Autowired annotation

D. Test class must be public

Solution

1. Step 1: Identify why TestRestTemplate bean is missing

   By default, @SpringBootTest does not start the web server unless webEnvironment is set, so TestRestTemplate bean is not created.

2. Step 2: Fix by adding webEnvironment

   Adding webEnvironment = WebEnvironment.RANDOM_PORT or DEFINED_PORT starts the server and creates the bean.

3. Final Answer:

   Missing webEnvironment setting to start web server -> Option B

4. Quick Check:

   webEnvironment needed for TestRestTemplate bean [OK]

Hint: Add webEnvironment to enable TestRestTemplate bean [OK]

Common Mistakes:

• Assuming TestRestTemplate is always available
• Forgetting to set webEnvironment in @SpringBootTest
• Thinking @Autowired is missing

5. You want to write an integration test that loads the full Spring Boot context but disables the web server startup to speed up tests. Which @SpringBootTest configuration should you use?

hard

A. @SpringBootTest(webEnvironment = WebEnvironment.NONE)

B. @SpringBootTest(webEnvironment = WebEnvironment.MOCK)

C. @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)

D. @SpringBootTest(webEnvironment = WebEnvironment.DEFINED_PORT)

Solution

1. Step 1: Understand webEnvironment options

   WebEnvironment.NONE disables web server startup but loads full context. MOCK uses mock servlet environment, RANDOM_PORT and DEFINED_PORT start real servers.

2. Step 2: Choose option that disables web server

   To speed up tests without web server, use WebEnvironment.NONE.

3. Final Answer:

   @SpringBootTest(webEnvironment = WebEnvironment.NONE) -> Option A

4. Quick Check:

   Disable web server with WebEnvironment.NONE [OK]

Hint: Use WebEnvironment.NONE to skip web server startup [OK]

Common Mistakes:

• Using MOCK which still sets up servlet environment
• Starting real server with RANDOM_PORT or DEFINED_PORT
• Confusing NONE with MOCK