0Pricing
Spring Boot 4 Complete Guide · レッスン

Spring Bootによる結合テスト

`@SpringBootTest`を使用して、RESTコントローラーとデータリポジトリの結合テストを実施します。

「Spring Bootによる結合テスト」はCoddyKit上の無料Spring Boot 4 Complete Guideレッスンです。 これはレッスン2/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはSpring Boot 4 Complete Guide学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

What is Integration Testing?

Welcome to integration testing with Spring Boot! So far, you've learned about unit testing, which isolates small pieces of code.

Integration tests, on the other hand, verify that different components of your application work correctly together. This often involves multiple layers, like your web controller, service, and even the database.

  • They test the 'glue' between components.
  • They catch issues that unit tests might miss.
  • They provide higher confidence in your application's behavior.

@SpringBootTest Annotation

The cornerstone of integration testing in Spring Boot is the @SpringBootTest annotation.

When you use @SpringBootTest, it loads the full Spring application context. This means all your beans (components), configurations, and properties are initialized, just like when your application starts normally.

It's powerful, but also heavier and slower than unit tests because it brings up more of your application.

A Simple Service Example

Let's imagine a simple greeting service that we want to test. This service will be part of our Spring Boot application.

Run this code to see the application context start, though it won't do much without an endpoint.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Service;

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

@Service
class GreetingService {
  public String greet(String name) {
    return "Hello, " + name + "!";
  }
}

Testing a Service with @SpringBootTest

Here's how you'd write an integration test for our GreetingService. Notice we @Autowired the service directly.

When this test runs, @SpringBootTest ensures the GreetingService bean is available in the test context.

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class GreetingServiceIT {

  @Autowired
  private GreetingService greetingService;

  @Test
  void contextLoads() {
    assertThat(greetingService).isNotNull();
  }

  @Test
  void greetReturnsCorrectMessage() {
    String result = greetingService.greet("Coddy");
    assertThat(result).isEqualTo("Hello, Coddy!");
  }
}

Testing Web Layer with MockMvc

For testing REST controllers, we often don't want to start a full HTTP server. This is where MockMvc comes in.

MockMvc allows you to perform requests against your controllers in a simulated environment, without needing an actual running server. It's faster and more controlled.

  • Use @AutoConfigureMockMvc with @SpringBootTest.
  • Inject MockMvc to make requests.
  • Assert on status, content, and headers.

A Simple REST Controller

Let's add a simple REST controller to our application. This controller uses our GreetingService.

Run this code to start the application with the controller. You could access /api/greet?name=World in a browser if you had a full setup.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

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

@RestController
class GreetingController {
  private final GreetingService greetingService;

  @Autowired
  public GreetingController(GreetingService service) {
    this.greetingService = service;
  }

  @GetMapping("/api/greet")
  public String greetUser(@RequestParam String name) {
    return greetingService.greet(name);
  }
}

@Service
class GreetingService {
  public String greet(String name) {
    return "Hello, " + name + "!";
  }
}

Testing GET Requests with MockMvc

Here's how to test our GreetingController's GET endpoint using MockMvc. We simulate an HTTP GET request to /api/greet with a query parameter.

We then assert that the HTTP status is OK (200) and the response content matches our expectation.

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
class GreetingControllerIT {

  @Autowired
  private MockMvc mockMvc;

  @Test
  void greetUserEndpointReturnsCorrectMessage() throws Exception {
    mockMvc.perform(get("/api/greet?name=Coddy"))
           .andExpect(status().isOk())
           .andExpect(content().string("Hello, Coddy!"));
  }
}

Testing POST Requests

Testing POST requests with MockMvc is similar but involves specifying the HTTP method and potentially a request body. You often need to set the Content-Type header.

For example, if you had an endpoint to create a new user, you'd send a JSON payload in the request body.

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

// Assuming a controller with @PostMapping("/api/users")
// and a method accepting @RequestBody User user

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIT {

  @Autowired
  private MockMvc mockMvc;

  @Test
  void createUserEndpointReturnsCreatedStatus() throws Exception {
    String newUserJson = "{\"name\":\"Jane Doe\", \"email\":\"jane@example.com\"}";

    mockMvc.perform(post("/api/users")
           .contentType(MediaType.APPLICATION_JSON)
           .content(newUserJson))
           .andExpect(status().isCreated()); // Expect HTTP 201 Created
  }
}

Testing Data Repositories

When testing your data layer (repositories), @SpringBootTest can also be used. You can @Autowired your repository interfaces directly.

It's common to use an in-memory database like H2 for these tests to ensure they are fast and don't affect your development database. Also, @Transactional can ensure tests clean up after themselves.

import static org.assertj.core.api.Assertions.assertThat;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

// Example Entity (e.g., in src/main/java/com/coddykit/User.java)
// public class User { private Long id; private String name; /* getters/setters */ }

// Example Repository (e.g., in src/main/java/com/coddykit/UserRepository.java)
interface User {
  Long getId();
  void setId(Long id);
  String getName();
  void setName(String name);
}

@Repository
interface UserRepository extends CrudRepository<User, Long> {
  User findByName(String name);
}

@SpringBootTest
@Transactional // Each test runs in a transaction and rolls back
class UserRepositoryIT {

  @Autowired
  private UserRepository userRepository;

  @Test
  void findByNameReturnsUser() {
    // Create and save a user for the test
    // (In a real scenario, User would be a JPA @Entity)
    User user = new User() {
      private Long id;
      private String name;
      public Long getId() { return id; }
      public void setId(Long id) { this.id = id; }
      public String getName() { return name; }
      public void setName(String name) { this.name = name; }
    };
    user.setName("TestUser");
    userRepository.save(user);

    User foundUser = userRepository.findByName("TestUser");
    assertThat(foundUser).isNotNull();
    assertThat(foundUser.getName()).isEqualTo("TestUser");
  }
}

Quick Check on @SpringBootTest

You've learned how @SpringBootTest helps with integration tests. Let's see if you can recall its primary function.

Recap: Integration Testing

Great job! You've explored the world of integration testing in Spring Boot.

  • @SpringBootTest loads the entire application context for comprehensive tests.
  • MockMvc allows you to simulate HTTP requests against your controllers without a running server, making web layer tests faster and more reliable.
  • You can test service and repository layers by autowiring them directly into @SpringBootTest classes, often with an in-memory database.

Integration tests are crucial for verifying that all parts of your Spring Boot application work harmoniously.

よくある質問

「Spring Bootによる結合テスト」レッスンは無料ですか？

はい。「Spring Bootによる結合テスト」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Spring Boot 4 Complete Guideコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Spring Boot 4 Complete Guideコースには全4レッスンが含まれています。

「Spring Bootによる結合テスト」で何を学びますか？

`@SpringBootTest`を使用して、RESTコントローラーとデータリポジトリの結合テストを実施します。 ブラウザで直接実行するハンズオンコードでSpring Boot 4 Complete Guideを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Spring Boot 4 Complete Guideを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのSpring Boot 4 Complete Guideは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン2/4です。

「Spring Bootによる結合テスト」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このSpring Boot 4 Complete Guideレッスンでコードを書いて実行できますか？

はい。すべてのSpring Boot 4 Complete Guideレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. JUnitとMockitoによる単体テスト
  2. Spring Bootによる結合テスト
  3. スライステストとTestcontainers
  4. MockMvcによるWebコントローラーのテスト
← Spring Boot 4 Complete Guideに戻る