devskill 2.0.7 → 2.0.8

package/skills/spring-boot-testing/references/resttestclient.md

@@ -0,0 +1,278 @@
+# RestTestClient
+
+Modern REST client testing with Spring Boot 4+ (replaces TestRestTemplate).
+
+## Overview
+
+RestTestClient is the modern alternative to TestRestTemplate in Spring Boot 4.0+. It provides a fluent, reactive API for testing REST endpoints.
+
+## Setup
+
+### Dependency (Spring Boot 4+)
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-restclient-test</artifactId>
+  <scope>test</scope>
+</dependency>
+```
+
+### Basic Configuration
+
+```java
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@AutoConfigureRestTestClient
+class OrderIntegrationTest {
+  
+  @Autowired
+  private RestTestClient restClient;
+}
+```
+
+## HTTP Methods
+
+### GET Request
+
+```java
+@Test
+void shouldGetOrder() {
+  restClient
+    .get()
+    .uri("/orders/1")
+    .exchange()
+    .expectStatus()
+    .isOk()
+    .expectBody(Order.class)
+    .value(order -> {
+      assertThat(order.getId()).isEqualTo(1L);
+      assertThat(order.getStatus()).isEqualTo("PENDING");
+    });
+}
+```
+
+### POST Request
+
+```java
+@Test
+void shouldCreateOrder() {
+  OrderRequest request = new OrderRequest("Laptop", 2);
+  
+  restClient
+    .post()
+    .uri("/orders")
+    .contentType(MediaType.APPLICATION_JSON)
+    .body(request)
+    .exchange()
+    .expectStatus()
+    .isCreated()
+    .expectHeader()
+    .location("/orders/1")
+    .expectBody(Long.class)
+    .isEqualTo(1L);
+}
+```
+
+### PUT Request
+
+```java
+@Test
+void shouldUpdateOrder() {
+  restClient
+    .put()
+    .uri("/orders/1")
+    .body(new OrderUpdate("COMPLETED"))
+    .exchange()
+    .expectStatus()
+    .isOk();
+}
+```
+
+### DELETE Request
+
+```java
+@Test
+void shouldDeleteOrder() {
+  restClient
+    .delete()
+    .uri("/orders/1")
+    .exchange()
+    .expectStatus()
+    .isNoContent();
+}
+```
+
+## Response Assertions
+
+### Status Codes
+
+```java
+restClient
+  .get()
+  .uri("/orders/1")
+  .exchange()
+  .expectStatus()
+  .isOk()           // 200
+  .isCreated()      // 201
+  .isNoContent()    // 204
+  .isBadRequest()   // 400
+  .isNotFound()     // 404
+  .is5xxServerError() // 5xx
+  .isEqualTo(200);  // Specific code
+```
+
+### Headers
+
+```java
+restClient
+  .post()
+  .uri("/orders")
+  .exchange()
+  .expectHeader()
+  .location("/orders/1")
+  .contentType(MediaType.APPLICATION_JSON)
+  .exists("X-Request-Id")
+  .valueEquals("X-Api-Version", "v1");
+```
+
+### Body Assertions
+
+```java
+restClient
+  .get()
+  .uri("/orders/1")
+  .exchange()
+  .expectBody(Order.class)
+  .value(order -> assertThat(order.getId()).isEqualTo(1L))
+  .returnResult();
+```
+
+### JSON Path
+
+```java
+restClient
+  .get()
+  .uri("/orders")
+  .exchange()
+  .expectBody()
+  .jsonPath("$.content[0].id").isEqualTo(1)
+  .jsonPath("$.content[0].status").isEqualTo("PENDING")
+  .jsonPath("$.totalElements").isNumber();
+```
+
+## Request Configuration
+
+### Headers
+
+```java
+restClient
+  .get()
+  .uri("/orders/1")
+  .header("Authorization", "Bearer token")
+  .header("X-Api-Key", "secret")
+  .exchange();
+```
+
+### Query Parameters
+
+```java
+restClient
+  .get()
+  .uri(uriBuilder -> uriBuilder
+    .path("/orders")
+    .queryParam("status", "PENDING")
+    .queryParam("page", 0)
+    .queryParam("size", 10)
+    .build())
+  .exchange();
+```
+
+### Path Variables
+
+```java
+restClient
+  .get()
+  .uri("/orders/{id}", 1L)
+  .exchange();
+```
+
+## With MockMvc
+
+RestTestClient can also work with MockMvc (no server startup):
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+@AutoConfigureRestTestClient
+class OrderMockMvcTest {
+  
+  @Autowired
+  private RestTestClient restClient;
+  
+  @Test
+  void shouldWorkWithMockMvc() {
+    // Uses MockMvc under the hood - no server startup
+    restClient
+      .get()
+      .uri("/orders/1")
+      .exchange()
+      .expectStatus()
+      .isOk();
+  }
+}
+```
+
+## Comparison: RestTestClient vs TestRestTemplate
+
+| Feature | RestTestClient | TestRestTemplate |
+| ------- | -------------- | ---------------- |
+| Style | Fluent/reactive | Imperative |
+| Spring Boot | 4.0+ | All versions (deprecated in 4) |
+| Assertions | Built-in | Manual |
+| MockMvc support | Yes | No |
+| Async | Native | Requires extra handling |
+
+## Migration from TestRestTemplate
+
+### Before (Deprecated)
+
+```java
+@Autowired
+private TestRestTemplate restTemplate;
+
+@Test
+void shouldGetOrder() {
+  ResponseEntity<Order> response = restTemplate
+    .getForEntity("/orders/1", Order.class);
+  
+  assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+  assertThat(response.getBody().getId()).isEqualTo(1L);
+}
+```
+
+### After (RestTestClient)
+
+```java
+@Autowired
+private RestTestClient restClient;
+
+@Test
+void shouldGetOrder() {
+  restClient
+    .get()
+    .uri("/orders/1")
+    .exchange()
+    .expectStatus()
+    .isOk()
+    .expectBody(Order.class)
+    .value(order -> assertThat(order.getId()).isEqualTo(1L));
+}
+```
+
+## Best Practices
+
+1. Use with @SpringBootTest(WebEnvironment.RANDOM_PORT) for real HTTP
+2. Use with @AutoConfigureMockMvc for faster tests without server
+3. Leverage fluent assertions for readability
+4. Test both success and error scenarios
+5. Verify headers for security/API versioning

package/skills/spring-boot-testing/references/sb4-migration.md

@@ -0,0 +1,181 @@
+# Spring Boot 4.0 Migration
+
+Key testing changes when migrating from Spring Boot 3.x to 4.0.
+
+## Dependency Changes
+
+### Modular Test Starters
+
+Spring Boot 4.0 introduces modular test starters:
+
+**Before (3.x):**
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-test</artifactId>
+  <scope>test</scope>
+</dependency>
+```
+
+**After (4.0) - WebMvc Testing:**
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-webmvc-test</artifactId>
+  <scope>test</scope>
+</dependency>
+```
+
+**After (4.0) - REST Client Testing:**
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-restclient-test</artifactId>
+  <scope>test</scope>
+</dependency>
+```
+
+## Annotation Migration
+
+### @MockBean → @MockitoBean
+
+**Deprecated (3.x):**
+
+```java
+@MockBean
+private OrderService orderService;
+```
+
+**New (4.0):**
+
+```java
+@MockitoBean
+private OrderService orderService;
+```
+
+### @SpyBean → @MockitoSpyBean
+
+**Deprecated (3.x):**
+
+```java
+@SpyBean
+private PaymentGatewayClient paymentClient;
+```
+
+**New (4.0):**
+
+```java
+@MockitoSpyBean
+private PaymentGatewayClient paymentClient;
+```
+
+## New Testing Features
+
+### RestTestClient
+
+Replaces TestRestTemplate (deprecated):
+
+```java
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@AutoConfigureRestTestClient
+class OrderIntegrationTest {
+  
+  @Autowired
+  private RestTestClient restClient;
+  
+  @Test
+  void shouldCreateOrder() {
+    restClient
+      .post()
+      .uri("/orders")
+      .body(new OrderRequest("Product", 2))
+      .exchange()
+      .expectStatus()
+      .isCreated()
+      .expectHeader()
+      .location("/orders/1");
+  }
+}
+```
+
+## JUnit 6 Support
+
+Spring Boot 4.0 uses JUnit 6 by default:
+
+- JUnit 4 is deprecated (use JUnit Vintage temporarily)
+- All JUnit 5 features still work
+- Remove JUnit 4 dependencies for clean migration
+
+## Testcontainers 2.0
+
+Module naming changed:
+
+**Before (1.x):**
+
+```xml
+<artifactId>postgresql</artifactId>
+```
+
+**After (2.0):**
+
+```xml
+<artifactId>testcontainers-postgresql</artifactId>
+```
+
+## Non-Singleton Bean Mocking
+
+Spring Framework 7 allows mocking prototype-scoped beans:
+
+```java
+@Component
+@Scope("prototype")
+public class OrderProcessor { }
+
+@SpringBootTest
+class OrderServiceTest {
+  @MockitoBean
+  private OrderProcessor orderProcessor; // Now works!
+}
+```
+
+## SpringExtension Context Changes
+
+Extension context is now test-method scoped by default.
+
+If tests fail with @Nested classes:
+
+```java
+@SpringExtensionConfig(useTestClassScopedExtensionContext = true)
+@SpringBootTest
+class OrderTest {
+  // Use old behavior
+}
+```
+
+## Migration Checklist
+
+- [ ] Replace @MockBean with @MockitoBean
+- [ ] Replace @SpyBean with @MockitoSpyBean
+- [ ] Update Testcontainers dependencies to 2.0 naming
+- [ ] Add modular test starters as needed
+- [ ] Migrate TestRestTemplate to RestTestClient
+- [ ] Remove JUnit 4 dependencies
+- [ ] Update custom TestExecutionListener implementations
+- [ ] Test @Nested class behavior
+
+## Backward Compatibility
+
+Use "classic" starters for gradual migration:
+
+```xml
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-test-classic</artifactId>
+  <scope>test</scope>
+</dependency>
+```
+
+This provides old behavior while you migrate incrementally.

package/skills/spring-boot-testing/references/test-slices-overview.md

@@ -0,0 +1,203 @@
+# Test Slices Overview
+
+Quick reference for selecting the right Spring Boot test slice.
+
+## Decision Matrix
+
+| Annotation | Use When | Loads | Speed |
+| ---------- | -------- | ----- | ----- |
+| **None** (plain JUnit) | Testing pure business logic | Nothing | Fastest |
+| `@WebMvcTest` | Controller + HTTP layer | Controllers, MVC, Jackson | Fast |
+| `@DataJpaTest` | Repository queries | Repositories, JPA, DataSource | Fast |
+| `@RestClientTest` | REST client code | RestTemplate/RestClient, Jackson | Fast |
+| `@JsonTest` | JSON serialization | ObjectMapper only | Fastest slice |
+| `@WebFluxTest` | Reactive controllers | Controllers, WebFlux | Fast |
+| `@DataJdbcTest` | JDBC repositories | Repositories, JDBC | Fast |
+| `@DataMongoTest` | MongoDB repositories | Repositories, MongoDB | Fast |
+| `@DataRedisTest` | Redis repositories | Repositories, Redis | Fast |
+| `@SpringBootTest` | Full integration | Entire application | Slow |
+
+## Selection Guide
+
+### Use NO Annotation (Plain Unit Test)
+
+```java
+class PriceCalculatorTest {
+  private PriceCalculator calculator = new PriceCalculator();
+  
+  @Test
+  void shouldApplyDiscount() {
+    var result = calculator.applyDiscount(100, 0.1);
+    assertThat(result).isEqualTo(new BigDecimal("90.00"));
+  }
+}
+```
+
+**When**: Pure business logic, no dependencies or simple dependencies mockable via constructor injection.
+
+### Use @WebMvcTest
+
+```java
+@WebMvcTest(OrderController.class)
+class OrderControllerTest {
+  @Autowired private MockMvcTester mvc;
+  @MockitoBean private OrderService orderService;
+}
+```
+
+**When**: Testing request mapping, validation, JSON mapping, security, filters.
+
+**What you get**: MockMvc, ObjectMapper, Spring Security (if present), exception handlers.
+
+### Use @DataJpaTest
+
+```java
+@DataJpaTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+@Testcontainers
+class OrderRepositoryTest {
+  @Container
+  static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:18");
+}
+```
+
+**When**: Testing custom JPA queries, entity mappings, transaction behavior, cascade operations.
+
+**What you get**: Repository beans, EntityManager, TestEntityManager, transaction support.
+
+### Use @RestClientTest
+
+```java
+@RestClientTest(WeatherService.class)
+class WeatherServiceTest {
+  @Autowired private WeatherService weatherService;
+  @Autowired private MockRestServiceServer server;
+}
+```
+
+**When**: Testing REST clients that call external APIs.
+
+**What you get**: MockRestServiceServer to stub HTTP responses.
+
+### Use @JsonTest
+
+```java
+@JsonTest
+class OrderJsonTest {
+  @Autowired private JacksonTester<Order> json;
+}
+```
+
+**When**: Testing custom serializers/deserializers, complex JSON mapping.
+
+### Use @SpringBootTest
+
+```java
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@AutoConfigureRestTestClient
+class OrderIntegrationTest {
+  @Autowired private RestTestClient restClient;
+}
+```
+
+**When**: Testing full request flow, security filters, database interactions together.
+
+**What you get**: Full application context, embedded server (optional), real beans.
+
+## Common Mistakes
+
+1. **Using @SpringBootTest for everything** - Slows down your test suite unnecessarily
+2. **@WebMvcTest without mocking services** - Causes context loading failures
+3. **@DataJpaTest with @MockBean** - Defeats the purpose (you want real repositories)
+4. **Multiple slices in one test** - Each slice is a separate test class
+
+## Java 25 Features in Tests
+
+### Records for Test Data
+
+```java
+record OrderRequest(String product, int quantity) {}
+record OrderResponse(Long id, String status, BigDecimal total) {}
+```
+
+### Pattern Matching in Tests
+
+```java
+@Test
+void shouldHandleDifferentOrderTypes() {
+  var order = orderService.create(new OrderRequest("Product", 2));
+  
+  switch (order) {
+    case PhysicalOrder po -> assertThat(po.getShippingAddress()).isNotNull();
+    case DigitalOrder do_ -> assertThat(do_.getDownloadLink()).isNotNull();
+    default -> throw new IllegalStateException("Unknown order type");
+  }
+}
+```
+
+### Text Blocks for JSON
+
+```java
+@Test
+void shouldParseComplexJson() {
+  var json = """
+    {
+      "id": 1,
+      "status": "PENDING",
+      "items": [
+        {"product": "Laptop", "price": 999.99},
+        {"product": "Mouse", "price": 29.99}
+      ]
+    }
+    """;
+  
+  assertThat(mvc.post().uri("/orders")
+    .contentType(APPLICATION_JSON)
+    .content(json))
+    .hasStatus(CREATED);
+}
+```
+
+### Sequenced Collections
+
+```java
+@Test
+void shouldReturnOrdersInSequence() {
+  var orders = orderRepository.findAll();
+  
+  assertThat(orders.getFirst().getStatus()).isEqualTo("NEW");
+  assertThat(orders.getLast().getStatus()).isEqualTo("COMPLETED");
+  assertThat(orders.reversed().getFirst().getStatus()).isEqualTo("COMPLETED");
+}
+```
+
+## Dependencies by Slice
+
+```xml
+<!-- WebMvcTest -->
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-webmvc-test</artifactId>
+  <scope>test</scope>
+</dependency>
+
+<!-- DataJpaTest -->
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-data-jpa</artifactId>
+</dependency>
+
+<!-- RestClientTest -->
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-starter-restclient-test</artifactId>
+  <scope>test</scope>
+</dependency>
+
+<!-- Testcontainers -->
+<dependency>
+  <groupId>org.springframework.boot</groupId>
+  <artifactId>spring-boot-testcontainers</artifactId>
+  <scope>test</scope>
+</dependency>
+```