Spring Boot TDD

Spring Boot TDD-Workflow

TDD-Anleitung für Spring Boot-Dienste mit 80%+ Abdeckung (Unit + Integration).

Wann verwenden

• Neue Features oder Endpunkte
• Fehlerbehebungen oder Refaktorisierungen
• Hinzufügen von Datenzugriffslogik oder Sicherheitsregeln

Workflow

1. Tests zuerst schreiben (sie sollten fehlschlagen)
2. Minimale Implementierung schreiben, um Tests zu bestehen
3. Refaktorisieren, während Tests grün sind
4. Abdeckung erzwingen (JaCoCo)

Unit-Tests (JUnit 5 + Mockito)

@ExtendWith(MockitoExtension.class)
class MarketServiceTest {
  @Mock MarketRepository repo;
  @InjectMocks MarketService service;

  @Test
  void createsMarket() {
    CreateMarketRequest req = new CreateMarketRequest("name", "desc", Instant.now(), List.of("cat"));
    when(repo.save(any())).thenAnswer(inv -> inv.getArgument(0));

    Market result = service.create(req);

    assertThat(result.name()).isEqualTo("name");
    verify(repo).save(any());
  }
}

Muster:

• Arrange-Act-Assert
• Partial Mocks vermeiden; explizites Stubbing bevorzugen
• @ParameterizedTest für Varianten verwenden

Web Layer Tests (MockMvc)

@WebMvcTest(MarketController.class)
class MarketControllerTest {
  @Autowired MockMvc mockMvc;
  @MockBean MarketService marketService;

  @Test
  void returnsMarkets() throws Exception {
    when(marketService.list(any())).thenReturn(Page.empty());

    mockMvc.perform(get("/api/markets"))
        .andExpect(status().isOk())
        .andExpect(jsonPath("$.content").isArray());
  }
}

Integrationstests (SpringBootTest)

@SpringBootTest
@AutoConfigureMockMvc
@ActiveProfiles("test")
class MarketIntegrationTest {
  @Autowired MockMvc mockMvc;

  @Test
  void createsMarket() throws Exception {
    mockMvc.perform(post("/api/markets")
        .contentType(MediaType.APPLICATION_JSON)
        .content("""
          {"name":"Test","description":"Desc","endDate":"2030-01-01T00:00:00Z","categories":["general"]}
        """))
      .andExpect(status().isCreated());
  }
}

Persistenztests (DataJpaTest)

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(TestContainersConfig.class)
class MarketRepositoryTest {
  @Autowired MarketRepository repo;

  @Test
  void savesAndFinds() {
    MarketEntity entity = new MarketEntity();
    entity.setName("Test");
    repo.save(entity);

    Optional<MarketEntity> found = repo.findByName("Test");
    assertThat(found).isPresent();
  }
}

Testcontainer

• Wiederverwendbare Container für Postgres/Redis verwenden, um die Produktion abzubilden
• Über @DynamicPropertySource JDBC-URLs in den Spring-Kontext injizieren

Abdeckung (JaCoCo)

Maven-Ausschnitt:

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.14</version>
  <executions>
    <execution>
      <goals><goal>prepare-agent</goal></goals>
    </execution>
    <execution>
      <id>report</id>
      <phase>verify</phase>
      <goals><goal>report</goal></goals>
    </execution>
  </executions>
</plugin>

Assertions

• AssertJ (assertThat) wegen Lesbarkeit bevorzugen
• Für JSON-Antworten jsonPath verwenden
• Für Ausnahmen: assertThatThrownBy(...)

Test-Daten-Builder

class MarketBuilder {
  private String name = "Test";
  MarketBuilder withName(String name) { this.name = name; return this; }
  Market build() { return new Market(null, name, MarketStatus.ACTIVE); }
}

CI-Befehle

• Maven: mvn -T 4 test oder mvn verify
• Gradle: ./gradlew test jacocoTestReport

Denken Sie daran: Tests schnell, isoliert und deterministisch halten. Verhalten testen, nicht Implementierungsdetails.