0Pricing
Spring Boot 4 Complete Guide · Ders

Spring Boot ile Entegrasyon Testleri

`@SpringBootTest` kullanarak REST denetleyicileriniz ve veri depolarınız için entegrasyon testleri gerçekleştirin.

Spring Boot ile Entegrasyon Testleri, CoddyKit'te ücretsiz bir Spring Boot 4 Complete Guide dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Spring Boot 4 Complete Guide öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Spring Boot 4 Complete Guide kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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.

Sıkça Sorulan Sorular

“Spring Boot ile Entegrasyon Testleri” dersi ücretsiz mi?

Evet — “Spring Boot ile Entegrasyon Testleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Spring Boot 4 Complete Guide kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Spring Boot 4 Complete Guide kursu toplamda 4 dersten oluşur.

“Spring Boot ile Entegrasyon Testleri” dersinde ne öğreneceğim?

`@SpringBootTest` kullanarak REST denetleyicileriniz ve veri depolarınız için entegrasyon testleri gerçekleştirin. Spring Boot 4 Complete Guide ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Spring Boot 4 Complete Guide öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Spring Boot 4 Complete Guide, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Spring Boot ile Entegrasyon Testleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Spring Boot 4 Complete Guide dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Spring Boot 4 Complete Guide dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. JUnit ve Mockito ile Birim Testleri
  2. Spring Boot ile Entegrasyon Testleri
  3. Katman Testleri ve TestContainers
  4. Web Denetleyicilerini MockMvc ile Test Etme
← Spring Boot 4 Complete Guide Sayfasına Dön