Testing Mastery: JUnit, Mockito & Integration Tests · Lesson

Spring Test Context Framework

Understand how Spring's test context framework initializes and manages application contexts for integration tests.

Spring Test Context Framework is a free Testing Mastery: JUnit, Mockito & Integration Tests lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Testing Mastery: JUnit, Mockito & Integration Tests learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Spring Test Context Intro

Welcome to Spring Boot integration testing! When you write tests for Spring applications, you need a way to bring up a part of your application. That's where the Spring Test Context Framework comes in.

It provides the infrastructure to load and manage an ApplicationContext for your tests, ensuring they run in a Spring-aware environment. This is crucial for tests that interact with beans, services, or data layers.

The @SpringBootTest Annotation

The core of Spring Boot integration testing is the @SpringBootTest annotation. It tells JUnit to bootstrap the Spring Boot application context for your test.

It starts a full ApplicationContext.
It finds the main configuration class (often your @SpringBootApplication class).
It provides access to all your Spring beans within the test.

Think of it as running your entire application, but specifically for your test's needs.

How Contexts Are Loaded

When @SpringBootTest is used, Spring's test framework looks for your main application class (the one annotated with @SpringBootApplication) and uses it to create an ApplicationContext.

This context is essentially a container for all the components (beans) of your application. Your test then runs against this live application context, allowing it to interact with actual services, repositories, and other Spring-managed components.

Context Caching for Speed

Loading a full Spring ApplicationContext can be slow. To speed up your test suite, the Spring Test Context Framework intelligently caches contexts.

If multiple tests require the exact same context configuration, Spring will reuse the previously loaded context.
This significantly reduces test execution time, especially in large projects.
The context is only reloaded if the configuration (e.g., properties, active profiles) changes.

Basic Spring App Example

Here's a minimal Spring Boot application. When you use @SpringBootTest, the framework will load a context based on this class, making its beans available to your tests.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class MyApp {

  public static void main(String[] args) {
    ApplicationContext context = SpringApplication.run(MyApp.class, args);
    System.out.println("App context loaded: " + (context != null));
  }
}

Using @SpringBootTest (Test)

Now, let's see how a test would use @SpringBootTest to load the context for the MyApp from the previous scene. We inject the ApplicationContext to verify it's loaded.

Notice this test class doesn't have a main method itself, as JUnit runners handle its execution.

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
class MyApplicationTests {

  @Test
  void contextLoads(ApplicationContext context) {
    assertThat(context).isNotNull();
    System.out.println("ApplicationContext loaded for test!");
  }
}

Customizing Web Environment

For web applications, @SpringBootTest can start a web server for your tests. You control this behavior using the webEnvironment attribute:

MOCK (default): Provides a mock servlet environment.
RANDOM_PORT: Starts an embedded server on a random port.
DEFINED_PORT: Starts an embedded server on the default or configured port.
NONE: Does not start an embedded server.

RANDOM_PORT is often preferred to avoid port conflicts.

Web Environment Example

Here's how you'd configure @SpringBootTest to start a web server on a random port. This allows you to perform actual HTTP requests against your application within your tests.

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.beans.factory.annotation.Value;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class WebAppTests {

  @Value(value="${local.server.port}")
  private int port;

  @Test
  void serverStarts() {
    assertThat(port).isNotZero();
    System.out.println("Web server started on port: " + port);
  }
}

Overriding Test Properties

Sometimes, you need specific configuration properties for your tests that differ from your main application (e.g., a test database URL). You can override these using the properties attribute in @SpringBootTest.

This allows you to isolate your test environment without changing production code.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;

@SpringBootApplication
public class PropApp implements CommandLineRunner {

  @Value("${app.message:Default Message}")
  private String message;

  public static void main(String[] args) {
    SpringApplication.run(PropApp.class, args);
  }

  @Override
  public void run(String... args) throws Exception {
    System.out.println("App Message: " + message);
  }
}

Quick Check

Which @SpringBootTest.WebEnvironment option would you use to start an embedded web server on an available, random port?

Recap: Spring Test Context

You've learned about the Spring Test Context Framework, a powerful tool for integration testing. We covered:

The purpose of the framework and @SpringBootTest.
How application contexts are loaded and cached.
Customizing test environments with webEnvironment.
Overriding properties for test-specific configurations.

This foundation is essential for writing robust and efficient Spring Boot integration tests!

Frequently asked questions

Is the “Spring Test Context Framework” lesson free?

Yes — the full text of “Spring Test Context Framework” is free to read here on the web, and the Testing Mastery: JUnit, Mockito & Integration Tests course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Testing Mastery: JUnit, Mockito & Integration Tests course, upgrade to CoddyKit PRO.

What will I learn in “Spring Test Context Framework”?

Understand how Spring's test context framework initializes and manages application contexts for integration tests. You practise Testing Mastery: JUnit, Mockito & Integration Tests with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Testing Mastery: JUnit, Mockito & Integration Tests?

No prior experience is required. Testing Mastery: JUnit, Mockito & Integration Tests on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Spring Test Context Framework” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Testing Mastery: JUnit, Mockito & Integration Tests lesson?

Yes. Every Testing Mastery: JUnit, Mockito & Integration Tests lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Spring Test Context Framework
Testing RESTful APIs
Embedded Databases for Tests
Testing Web Layers with @WebMvcTest and MockMvc

← Back to Testing Mastery: JUnit, Mockito & Integration Tests