Skip to content

giuseppe-trisciuoglio/developer-kit / plugins/developer-kit-java/skills/unit-test-bean-validation

unit-test-bean-validation

Verified

Provides patterns for unit testing Jakarta Bean Validation (JSR-380), including @Valid, @NotNull, @Min, @Max, @Email constraints with Hibernate Validator. Generates custom validator tests, constraint violation assertions, validation groups, and parameterized validation tests. Validates data integrity logic without Spring context. Use when writing validation tests, bean validation tests, or testing custom constraint validators.

FileKindSize
SKILL.mdskill md7.0 KB
references/advanced-patterns.mdmarkdown3.4 KB
references/custom-validators.mdmarkdown2.9 KB

references/advanced-patterns.md

View on GitHub
# Advanced Validation Patterns Reference

## Validation Groups

### Defining Groups

```java
public interface CreateValidation {}
public interface UpdateValidation {}
public interface AdminValidation {}
```

### Using Groups in DTOs

```java
class UserDto {
  @NotNull(groups = CreateValidation.class)
  private String name;

  @Min(value = 0, groups = {CreateValidation.class, UpdateValidation.class})
  private int age;
}
```

### Testing Groups

```java
class ValidationGroupsTest extends BaseValidationTest {

  @Test
  void shouldRequireNameOnlyDuringCreation() {
    UserDto user = new UserDto(null, 25);

    Set<ConstraintViolation<UserDto>> violations =
        validator.validate(user, CreateValidation.class);

    assertThat(violations)
      .extracting(ConstraintViolation::getPropertyPath)
      .extracting(Path::toString)
      .contains("name");
  }

  @Test
  void shouldAllowNullNameDuringUpdate() {
    UserDto user = new UserDto(null, 25);
    assertThat(validator.validate(user, UpdateValidation.class)).isEmpty();
  }

  @Test
  void shouldValidateMultipleGroups() {
    UserDto user = new UserDto("Alice", -5);
    Set<ConstraintViolation<UserDto>> violations =
        validator.validate(user, CreateValidation.class, UpdateValidation.class);
    assertThat(violations).isNotEmpty();
  }
}
```

## Parameterized Tests

### Email Validation

```java
class EmailValidationTest extends BaseValidationTest {

  @ParameterizedTest
  @ValueSource(strings = {
    "user@example.com",
    "john.doe+tag@example.co.uk",
    "admin@subdomain.example.com"
  })
  void shouldAcceptValidEmails(String email) {
    UserDto user = new UserDto("Alice", email);
    assertThat(validator.validate(user)).isEmpty();
  }

  @ParameterizedTest
  @ValueSource(strings = {
    "invalid-email", "user@", "@example.com", "user name@example.com"
  })
  void shouldRejectInvalidEmails(String email) {
    UserDto user = new UserDto("Alice", email);
    assertThat(validator.validate(user)).isNotEmpty();
  }
}
```

### Multiple Parameters

```java
class RangeValidationTest extends BaseValidationTest {

  @ParameterizedTest
  @CsvSource({
    "0, 100, true",
    "-1, 100, false",
    "0, 0, false",
    "50, 100, true"
  })
  void shouldValidateRange(int min, int max, boolean shouldPass) {
    RangeDto dto = new RangeDto(min, max);
    var violations = validator.validate(dto);
    assertThat(violations.isEmpty()).isEqualTo(shouldPass);
  }
}
```

## Debugging Failed Tests

### When Tests Fail

1. **Check violation count**: `assertThat(violations).hasSize(n)`
2. **Inspect property path**: `violation.getPropertyPath().toString()`
3. **Verify message**: `violation.getMessage()`
4. **Check invalid value**: `violation.getInvalidValue()`

```java
@Test
void debugFailedValidation() {
  UserDto user = new UserDto("", "invalid");

  Set<ConstraintViolation<UserDto>> violations = validator.validate(user);

  // Debug output
  violations.forEach(v -> System.out.println(
    v.getPropertyPath() + ": " + v.getMessage()
  ));

  assertThat(violations).hasSize(2);
}
```

### Common Issues

| Issue | Cause | Solution |
|-------|-------|----------|
| `ConstraintViolation` null | Object is valid or constraint doesn't fire | Check annotation parameters |
| Wrong property path | Wrong field annotated | Verify `@Constraint(validatedBy=)` |
| Null passes validation | Constraint allows null | Add `@NotNull` |
| Multiple violations | Multiple constraints fail | Use `hasSize()` to verify count |
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 197kUpdated Claude CodeCodexVerifiedInstall