Testing Mastery: JUnit, Mockito & Integration Tests · Aula

Estrutura de Contexto de Testes do Spring

Entenda como a estrutura de contexto de testes do Spring inicializa e gerencia contextos de aplicação para testes de integração.

Estrutura de Contexto de Testes do Spring é uma aula grátis de Testing Mastery: JUnit, Mockito & Integration Tests no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Testing Mastery: JUnit, Mockito & Integration Tests, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Testing Mastery: JUnit, Mockito & Integration Tests inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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!

Perguntas Frequentes

A aula “Estrutura de Contexto de Testes do Spring” é grátis?

Sim — o texto completo de “Estrutura de Contexto de Testes do Spring” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Testing Mastery: JUnit, Mockito & Integration Tests, atualize para CoddyKit PRO. O curso de Testing Mastery: JUnit, Mockito & Integration Tests inclui 4 aulas no total.

O que vou aprender em “Estrutura de Contexto de Testes do Spring”?

Entenda como a estrutura de contexto de testes do Spring inicializa e gerencia contextos de aplicação para testes de integração. Você pratica Testing Mastery: JUnit, Mockito & Integration Tests com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Testing Mastery: JUnit, Mockito & Integration Tests?

Nenhuma experiência prévia é necessária. Testing Mastery: JUnit, Mockito & Integration Tests no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Estrutura de Contexto de Testes do Spring”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Testing Mastery: JUnit, Mockito & Integration Tests?

Sim. Cada aula de Testing Mastery: JUnit, Mockito & Integration Tests inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Estrutura de Contexto de Testes do Spring
Testando APIs RESTful
Bancos de Dados Incorporados para Testes
Testando camadas web com @WebMvcTest e MockMvc

← Voltar para Testing Mastery: JUnit, Mockito & Integration Tests