ViolationMessage.of() with arguments

[ffroliva]

Dear Maki,

Some times need to create messages and I use ViolationMessage.of() for that.

However ViolationMessage doesn't accept arguments. This limits me to only have plain messages.

For example consider a message as follows: "Please provide a number between {0} and {1}" and I need to send the arguments to be resolved. Some times I use the messageKey and I would need to have the arguments available to be resolved in a GlobalExceptionHandler with a MessageSource to be translated.

Currently I am addressing that with CustomConstraints but It would be useful to have another constructor to resolve te argumentos in ViolationMessage.of()

I understand that in CustomConstraint the first attribute is the name so {0} is reserved.

My suggestion: ViolationMessage.of(String messageKey, String defaultMessageFormat, Object[] args)

What are you thoughts on this?

[making]

I don't understand the case where a ViolationMessage with arguments is needed. I think the intended use is to use a CustomConstatraint.
Can you provide the full code for your use case?

[ffroliva]

Dear Maki,

Sorry for the delay in replying.

It would be helpful to have a way to provide the ViolationMessage the arguments so that I I can then generated a template message that could use them. Also my main go is to internationalize the message at some point.

Consider the following code:

import am.ik.yavi.builder.ValidatorBuilder;
import am.ik.yavi.constraint.charsequence.CodePoints;
import am.ik.yavi.core.Constraint;
import am.ik.yavi.core.ConstraintContext;
import am.ik.yavi.core.ConstraintViolation;
import am.ik.yavi.core.CustomConstraint;
import am.ik.yavi.core.Validator;
import am.ik.yavi.core.ViolationMessage;

import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.Assertions;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.Serializable;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

record Description( String value) implements Serializable {

}

@Slf4j
class DescriptionValidatorTest {


    @Test
    @DisplayName("Should fail validation for a description longer than 10 characters")
    void validateTooLongDescription() {
        Validator<Description> validator = ValidatorBuilder.of(Description.class)
                ._string(Description::value, "description", c -> c.codePoints(CodePoints.Range.of(5, 10))
                        .asWhiteList()
                        .message(ViolationMessage.of("DESCRIPTION_LENGTH_INVALID", "Description must be between {1} and {2} characters")))
                .build();
        String longDescription = "a".repeat(11);
        Description description = new Description(longDescription);
        List<ConstraintViolation> violations = validator.validate(description);


        assertThat(violations).hasSize(1);
        Object[] args = violations.getFirst().args();
        log.info("args content: {}", args);
        log.info("args length: {}", args.length);

        assertThat(violations.getFirst().messageKey()).isEqualTo("DESCRIPTION_LENGTH_INVALID");
        assertThat(violations.getFirst().message()).isEqualTo("Description must be between {1} and {2} characters");

        Assertions.assertThat(args).hasSize(2).contains(5, 3);

    }

    @Test
    @DisplayName("Should fail validation for a description longer than 10 characters")
    void validateTooLongWithCustomConstraintDescription() {

        Validator<Description> validator = ValidatorBuilder.of(Description.class)
                .constraint(Description::value, "description", Constraint::notNull)
                .constraintOnCondition(this::isDescriptionNotEmpty, b ->
                        b.constraintOnTarget(new DescriptionLengthConstraint(5, 10), "description"))
                .build();
        String longDescription = "a".repeat(11);
        Description description = new Description(longDescription);
        List<ConstraintViolation> violations = validator.validate(description);


        assertThat(violations).hasSize(1);
        Object[] args = violations.getFirst().args();
        log.info("args length: {}", args.length);
        for (int i = 0; i < args.length; i++) {
            log.info("arg[{}]: {}", i, args[i]);
        }

        assertThat(violations.getFirst().messageKey()).isEqualTo("DESCRIPTION_LENGTH_INVALID");
        assertThat(violations.getFirst().message()).isEqualTo("Description must be between 5 and 10 characters");


    }

    private boolean isDescriptionNotEmpty(Description description, ConstraintContext constraintGroup) {
        return !description.value().isEmpty();
    }

    public static class DescriptionLengthConstraint implements CustomConstraint<Description> {

        private final int min;
        private final int max;

        /**
         * Constructs a new DescriptionLengthConstraint.
         *
         * @param min minimum allowed length
         * @param max maximum allowed length
         */
        public DescriptionLengthConstraint(int min, int max) {
            this.min = min;
            this.max = max;
        }

        @Override
        public boolean test(Description description) {
            if (description == null || description.value() == null) {
                return false;
            }

            int length = description.value().length();
            return length >= min && length <= max;
        }

        @Override
        public Object[] arguments(Description description) {
            return new Object[]{String.valueOf(min), String.valueOf(max)};
        }

        @Override
        public @NotNull String defaultMessageFormat() {
            return "Description must be between {1} and {2} characters";
        }

        @Override
        public @NotNull String messageKey() {
            return "DESCRIPTION_LENGTH_INVALID";
        }
    }
}

Do you think it would make sense to add such option to the ViolationMessage? I would think we could make it more robust. What do you think?

[making]

I still can't grasp what the pain point is.
The ViolationMessage class is the place to define static messages. Think of it as a line in messages.properties.
Messages are resolved in the ConstraintViolation class. It sounds like having the ViolationMessage class hold args and message format would be going beyond its intended role.

[ffroliva]

My point is, we have an interface Constraint<T, V, C extends Constraint<T, V, C>> that allow the user to overwrite the default message of a given validation but this interface does not allow the user to create messages that depends on parameters. The messages can be only simple messages. Maybe this interface could be expended to accept a SimpleMessageFormat for example or any other strategy that would allow the message to accept parameters. My message with param1 {0} and param2 {1} .

package am.ik.yavi.core;

import am.ik.yavi.core.ViolationMessage.Default;
import am.ik.yavi.jsr305.Nullable;
import java.util.Collection;
import java.util.Deque;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.function.Supplier;

public interface Constraint<T, V, C extends Constraint<T, V, C>> {
    C cast();

    default C message(String message) {
        ConstraintPredicate<V> predicate = (ConstraintPredicate)this.predicates().pollLast();
        if (predicate == null) {
            throw new IllegalStateException("no constraint found to override!");
        } else {
            this.predicates().addLast(predicate.overrideMessage(message));
            return this.cast();
        }
    }

    default C message(ViolationMessage message) {
        ConstraintPredicate<V> predicate = (ConstraintPredicate)this.predicates().pollLast();
        if (predicate == null) {
            throw new IllegalStateException("no constraint found to override!");
        } else {
            this.predicates().addLast(predicate.overrideMessage(message));
            return this.cast();
        }
    }

}

[making]

I'm sorry, but I'm having difficulty understanding what you're proposing here.

Perhaps you could provide a more concrete example contrasting the current implementation with your proposed enhancement to help me better understand your use case.