Execute Predicate for each element in collection

[3DExtended]

Is your feature request related to a problem? Please describe.
I am using this package for validating complex data structures and often need to validate lists or other collection types. I want to be able to validate list items without having to write a new validator specifically for each case in which the item occurs in a list.

For example, suppose there is a class with a list of persons, and I want to ensure that every person in the list is younger than 21 years. I don't want to write a separate validator for each list that contains a person as this would be overkill for such a simple validation.

Describe the solution you'd like
I would like to be able to validate list items without having to create an additional validator, similar to the functionality provided by FluentValidation.

Describe alternatives you've considered
One alternative is to write validators for each collection in my data structure, but this would create unnecessary overhead.

Additional context
I realize that the example above may not be the best, but it should help illustrate my issue.

[mvallim]

Hi @3DExtended,

Try running it that way, and see if that's exactly what you're looking for.

package playground;

import static br.com.fluentvalidator.predicate.ComparablePredicate.lessThan;
import static br.com.fluentvalidator.predicate.CollectionPredicate.empty;
import static br.com.fluentvalidator.predicate.LogicalPredicate.not;
import static br.com.fluentvalidator.predicate.StringPredicate.stringEmptyOrNull;
import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.hasItem;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasProperty;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;

import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

import org.junit.Test;

import br.com.fluentvalidator.AbstractValidator;
import br.com.fluentvalidator.context.Error;
import br.com.fluentvalidator.context.ValidationResult;

public class ForEachValidatorTests {
  
  public static class Professor implements Serializable {

    private static final long serialVersionUID = 1429362388128541582L;

    private final String name;

    private final List<Student> students;
    
    public Professor(final String name, final List<Student> students) {
      this.name = name;
      this.students = students;
    }

    public Professor(final String name) {
      this(name, new LinkedList<>());
    }

    public String getName() {
      return name;
    }

    public List<Student> getStudents() {
      return Collections.unmodifiableList(students);
    }
    
    public void addStudent(final Student student) {
      if (Objects.nonNull(student)) {
        this.students.add(student);
      }
    }

  }
  
  public static class Student implements Serializable {

    private static final long serialVersionUID = -2054087302972951675L;
    
    private final String name;
    
    private final Integer age;

    public Student(final String name, final Integer age) {
      this.name = name;
      this.age = age;
    }

    public String getName() {
      return name;
    }

    public Integer getAge() {
      return age;
    }
    
  }


  public static class ProfessorValidator extends AbstractValidator<Professor> {

    @Override
    public void rules() {
      
      failFastRule();
      
      ruleFor("name", Professor::getName)
        .must(not(stringEmptyOrNull()))
          .withAttempedValue(Professor::getName)
          .withMessage("'name' must be not null or empty");

      ruleFor("students", Professor::getStudents)
        .must(not(empty()))
          .withAttempedValue(Professor::getStudents)
          .withMessage("'students' must be not empty")
        .must(studentsNamePredicate())
          .when(not(empty()))
          .withAttempedValue(Professor::getStudents)
          .withMessage("some 'student' has name is empty or null")
        .must(studentsAgePredicate())
          .when(not(empty()))
          .withAttempedValue(Professor::getStudents)
          .withMessage("some 'student' is over 20 years old");
    }

    private static Predicate<List<Student>> studentsNamePredicate() {
      return list -> list.stream().map(Student::getName).allMatch(not(stringEmptyOrNull()));
    }

    private static Predicate<List<Student>> studentsAgePredicate() {
      return list -> list.stream().map(Student::getAge).allMatch(lessThan(21));
    }

  }
  
  @Test
  public void testSuccess() {
    
    final ProfessorValidator professorValidator = new ProfessorValidator();
    
    final Professor professor = new Professor("John");
    professor.addStudent(new Student("studentA", 20));
    professor.addStudent(new Student("studentB", 19));
    professor.addStudent(new Student("studentC", 18));
    
    final ValidationResult validationResult = professorValidator.validate(professor);
    
    assertThat(validationResult.isValid(), is(true));
  }
  
  @Test
  public void testFailWhenNameIsEmpty() {
    
    final ProfessorValidator professorValidator = new ProfessorValidator();
    
    final Professor professor = new Professor("John");
    professor.addStudent(new Student("", 20));
    
    final ValidationResult validationResult = professorValidator.validate(professor);
    
    assertThat(validationResult.isValid(), is(false));
    
    final Collection<Error> errors = validationResult.getErrors();
    
    assertThat(errors, hasSize(1));
    assertThat(errors, hasItem(
      allOf(
        hasProperty("attemptedValue", hasSize(1)),
        hasProperty("message", is("some 'student' has name is empty or null"))
      ))
    );
  }

  @Test
  public void testFailWhenAgeIsGreaterThan21() {
    
    final ProfessorValidator professorValidator = new ProfessorValidator();
    
    final Professor professor = new Professor("John");
    professor.addStudent(new Student("studentA", 21));
    
    final ValidationResult validationResult = professorValidator.validate(professor);
    
    assertThat(validationResult.isValid(), is(false));
    
    final Collection<Error> errors = validationResult.getErrors();
    
    assertThat(errors, hasSize(1));
    assertThat(errors, hasItem(
      allOf(
        hasProperty("attemptedValue", hasSize(1)),
        hasProperty("message", is("some 'student' is over 20 years old"))
      ))
    );
  }

}

Thanks for using and contributing.

Any questions just let me know.

[3DExtended]

That is exactly what I was looking for! Thank you for the comprehensive answer!