9.1.3 FluentValidation 更新破坏验证器模拟了吗？

Question

I updated to 9.1.3 version of the package and now my validator mocks do not work.

Somehow code runs no matter whether .Validate() returns true or false .

Here is the code for the validator mock:

validatorMock
    .Setup(x => x.Validate(It.IsAny<IValidationContext>()).IsValid)
    .Returns(false);

    Assert.Throws<ValidationException>(() => command.Execute(request), "Position field validation error");
    repositoryMock.Verify(repository => repository.EditPosition(It.IsAny<DbPosition>()), Times.Never);

And here is the test failing:

Message: 
      Position field validation error
      Expected: <FluentValidation.ValidationException>
      But was:  null

Validator.cs:

public class SampleValidator : AbstractValidator<Position>
    {
        public SampleValidator()
        {
            RuleFor(position => position.Name)
                .NotEmpty()
                .MaximumLength(80)
                .WithMessage("Position name is too long");

            RuleFor(position => position.Description)
                .NotEmpty()
                .MaximumLength(350)
                .WithMessage("Position description is too long");
        }
    }

Dependency Injection:

services.AddTransient<IValidator<Position>, SampleValidator>();

Usage:

public class SampleCommand : ISampleCommand
    {
        private readonly IValidator<Position> validator;
        private readonly ISampleRepository repository;
        private readonly IMapper<Position, DbPosition> mapper;

        public SampleCommand(
            [FromServices] IValidator<Position> validator,
            [FromServices] ISampleRepository repository,
            [FromServices] IMapper<Position, DbPosition> mapper)
        {
            this.validator = validator;
            this.repository = repository;
            this.mapper = mapper;
        }

        public bool Execute(Position request)
        {
            validator.ValidateAndThrow(request);

            var position = mapper.Map(request);

            return repository.EditPosition(position);
        }
    }

Validator Mocks in test:

private Mock<IValidator<EditPositionRequest>> validatorMock;
...
validatorMock = new Mock<IValidator<Position>>();

UPDATE

Before the update, all tests were running perfectly. Now they're ruined and I have to install the previous version.

Answer 1

Expanding on my comment:

Yes, 9.1 changed how throwing validation exceptions is handled.

Some context:

Validator classes return a ValidationResult with an IsValid boolean property. The ValidateAndThrow extension method checks this property, and throws an exception if IsValid is false. If you mocked the validator, you could still use the "real" ValidateAndThrow extension method on your mock to throw an exception if your mock returned an invalid validation result.

In FluentValidation 9.1, the logic for throwing the exception was moved out of the extension method and into the validator class itself, in the RaiseValidationException . This was done so that the logic for throwing the exception could be customized (by overriding this method) which couldn't be done before when it was an extension method.

// This is the ValidateAndThrow method definition versions older than 9.1
public static void ValidateAndThrow<T>(this IValidator<T> validator, T instance) {
  var result = validator.Validate(instance);
  
  if (!result.IsValid) {
    throw new ValidationException(result.Errors);
  }
}

// This is the ValidateAndThrowMethod in 9.1 and newer
public static void ValidateAndThrow<T>(this IValidator<T> validator, T instance) {
  validator.Validate(instance, options => {
    options.ThrowOnFailures();
  });
}

For runtime use, this doesn't make a difference - the exception is still thrown (unless you've overridden the method to prevent this).

However, this had the side effect that if you were relying on the exception being thrown by the extension method rather than the validator, this will have an undesirable result. This is really only the case when mocking the validator. Now when you create a mock, the exception won't be thrown because the mock doesn't behave as a real validator.

My recommendation with FluentValidation has always been "don't mock validators", instead treat them as black boxes and supply real validator instances with valid/invalid input for testing purposes - this leads to much less brittle tests in the long run. However, I'm also aware that it may not be possible to rewrite your tests in this way if you already have lots of them.

As a workaround, you can mock the overload of Validate that takes a ValidationContext and check the context for the ThrowOnFailures property, and have your mock throw the exception if this is set to true.

However, be aware that if you do this you could run into a situation where your mock behaves one way and the real validator behaves differently (if its RaiseValidationException message has been overridden).

As this is a breaking change, shouldn't it have been made in a major version? Ideally yes, this was my bad as I didn't foresee this particular use case.

Edit: Here's an example of creating a mock that checks the ThrowOnFailures property. The example uses the Moq library, but the same concept will apply to other mocking libraries too.

private static Mock<IValidator<T>> CreateFailingMockValidator<T>() {
  var mockValidator = new Mock<IValidator<T>>();

  var failureResult = new ValidationResult(new List<ValidationFailure>() {
    new ValidationFailure("Foo", "Bar")
  });

  // Setup the Validate/ValidateAsync overloads that take an instance.
  // These will never throw exceptions.
  mockValidator.Setup(p => p.Validate(It.IsAny<T>()))
    .Returns(failureResult).Verifiable();
  mockValidator.Setup(p => p.ValidateAsync(It.IsAny<T>(), It.IsAny<CancellationToken>()))
    .ReturnsAsync(failureResult);

  // Setup the Validate/ValidateAsync overloads that take a context.
  // This is the method called by ValidateAndThrow, so will potentially support throwing the exception.
  // Setup method invocations for with an exception and without.
  mockValidator.Setup(p => p.Validate(It.Is<ValidationContext<T>>(context => context.ThrowOnFailures)))
    .Throws(new ValidationException(failureResult.Errors));
  mockValidator.Setup(p => p.ValidateAsync(It.Is<ValidationContext<T>>(context => context.ThrowOnFailures), It.IsAny<CancellationToken>()))
    .Throws(new ValidationException(failureResult.Errors));

  // If ThrowOnFailures is false, return the result.
  mockValidator.Setup(p => p.Validate(It.Is<ValidationContext<T>>(context => !context.ThrowOnFailures)))
    .Returns(failureResult).Verifiable();
  mockValidator.Setup(p => p.ValidateAsync(It.Is<ValidationContext<T>>(context => !context.ThrowOnFailures), It.IsAny<CancellationToken>()))
    .ReturnsAsync(failureResult);

  return mockValidator;
}