Testing Mastery: JUnit, Mockito & Integration Tests · Lekcja

Framework kontekstu testowego Spring

Dowiedz się, jak framework kontekstu testowego Spring inicjalizuje i zarządza kontekstami aplikacji na potrzeby testów integracyjnych.

Framework kontekstu testowego Spring to bezpłatna lekcja Testing Mastery: JUnit, Mockito & Integration Tests na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Testing Mastery: JUnit, Mockito & Integration Tests, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Testing Mastery: JUnit, Mockito & Integration Tests zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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!

Często zadawane pytania

Czy lekcja „Framework kontekstu testowego Spring” jest bezpłatna?

Tak — pełny tekst „Framework kontekstu testowego Spring” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Testing Mastery: JUnit, Mockito & Integration Tests, przejdź na CoddyKit PRO. Kurs Testing Mastery: JUnit, Mockito & Integration Tests zawiera 4 lekcji w sumie.

Co nauczysz się w „Framework kontekstu testowego Spring”?

Dowiedz się, jak framework kontekstu testowego Spring inicjalizuje i zarządza kontekstami aplikacji na potrzeby testów integracyjnych. Ćwiczysz Testing Mastery: JUnit, Mockito & Integration Tests z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Testing Mastery: JUnit, Mockito & Integration Tests?

Nie wymagamy żadnego doświadczenia. Testing Mastery: JUnit, Mockito & Integration Tests w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Framework kontekstu testowego Spring”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Testing Mastery: JUnit, Mockito & Integration Tests?

Tak. Każda lekcja Testing Mastery: JUnit, Mockito & Integration Tests zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Framework kontekstu testowego Spring
Testowanie API RESTful
Wbudowane bazy danych na potrzeby testów
Testowanie warstwy webowej za pomocą @WebMvcTest i MockMvc

← Powrót do Testing Mastery: JUnit, Mockito & Integration Tests